### Install Allosaurus from Source

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Installs Allosaurus by cloning the repository and running the setup script. This method is useful for developers who want to modify the source code.

```bash
python setup.py install
```

--------------------------------

### Install Allosaurus Library

Source: https://context7.com/xinjli/allosaurus/llms.txt

Instructions for installing the Allosaurus package via pip or from the source repository.

```bash
pip install allosaurus
```

```bash
git clone https://github.com/xinjli/allosaurus.git
cd allosaurus
python setup.py install
```

--------------------------------

### Install Allosaurus using Pip

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Installs the Allosaurus library using pip, making it available for use in your Python projects. This is the recommended method for most users.

```bash
pip install allosaurus
```

--------------------------------

### Quick Start Inference with Allosaurus CLI

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Performs phone recognition on an audio file using the Allosaurus command-line interface. The input is an audio file, and the output is a sequence of phones.

```bash
python -m allosaurus.run -i <audio>
```

```bash
python -m allosaurus.run -i sample.wav
æ l u s ɔ ɹ s
```

--------------------------------

### Quick Start Inference with Allosaurus Python API

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Loads the Allosaurus recognizer model and performs phone recognition on an audio file using the Python API. This provides a programmatic way to integrate Allosaurus into applications.

```python
from allosaurus.app import read_recognizer

# load your model
model = read_recognizer()

# run inference -> æ l u s ɔ ɹ s
model.recognize('sample.wav')
```

--------------------------------

### Prepare Fine-Tuning Data

Source: https://context7.com/xinjli/allosaurus/llms.txt

Create required directory structures and feature files for training and validation datasets.

```bash
mkdir -p my_dataset/train my_dataset/validate
python -m allosaurus.bin.prep_feat --model uni2005 --path /path/to/my_dataset/train
python -m allosaurus.bin.prep_token --model uni2005 --lang eng --path /path/to/my_dataset/train
```

--------------------------------

### Model Lifecycle Management

Source: https://context7.com/xinjli/allosaurus/llms.txt

Commands to download, list, and remove pretrained models from the local environment.

```bash
python -m allosaurus.bin.download_model -m latest
python -m allosaurus.bin.download_model -m uni2005
python -m allosaurus.bin.list_model
python -m allosaurus.bin.remove_model
```

--------------------------------

### Manage Allosaurus Models via CLI

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Commands to list available phones, download new models, list local models, and remove specific models from the environment.

```bash
python -m allosaurus.bin.list_phone
python -m allosaurus.bin.download_model -m <model>
python -m allosaurus.bin.list_model
python -m allosaurus.bin.remove_model
```

--------------------------------

### Load Phone Recognition Model

Source: https://context7.com/xinjli/allosaurus/llms.txt

Demonstrates how to initialize the Allosaurus recognizer using default settings, specific model names, or custom configuration objects.

```python
from allosaurus.app import read_recognizer
from argparse import Namespace

# Load the default (latest) model
model = read_recognizer()

# Load specific models
model = read_recognizer('uni2005')
model = read_recognizer('eng2102')

# Load with custom configuration
config = Namespace(model='uni2005', device_id=0, lang='ipa', approximate=False, prior=None)
model = read_recognizer(config)
```

--------------------------------

### Manage Languages and Phone Inventories

Source: https://context7.com/xinjli/allosaurus/llms.txt

List supported languages and display phone inventories for specific models or languages.

```bash
python -m allosaurus.bin.list_lang
python -m allosaurus.bin.list_phone
python -m allosaurus.bin.list_phone --lang eng
python -m allosaurus.bin.list_phone --lang cmn --model uni2005
```

--------------------------------

### Prepare Text Features (Tokens) with Allosaurus

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

This command prepares text features (token IDs) from the text files. It requires the data directory path, a pretrained model, and the target language ID. Ensure the language ID's phone inventory matches your transcriptions to avoid errors. This generates a 'token' file mapping utterances to phone ID sequences.

```bash
python -m allosaurus.bin.prep_token --model=<some_pretrained_model> --lang=<your_target_language_id> --path=/path/to/your/directory (train or validate)
```

--------------------------------

### Prepare Audio Features with Allosaurus

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

This command extracts audio features from prepared wave files. It requires a path to the data directory (train or validate) and a pretrained model. The output includes feat.scp, feat.ark, and shape files, which are standard Kaldi formats.

```bash
python -m allosaurus.bin.prep_feat --model=some_pretrained_model --path=/path/to/your/directory (train or validate)
```

--------------------------------

### Allosaurus CLI Inference Options

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Provides detailed command-line options for Allosaurus inference, including specifying language, model, device, and output file. The input audio file or directory is mandatory.

```bash
python -m allosaurus.run [--lang <language name>] [--model <model name>] [--device_id <gpu_id>] [--output <output_file>] [--topk <int>] -i <audio file/directory>
```

--------------------------------

### Run Inference with Fine-Tuned Model - Allosaurus CLI

Source: https://context7.com/xinjli/allosaurus/llms.txt

Use a fine-tuned Allosaurus model for inference on an audio file. Specify the model name, language, and input audio file path.

```bash
python -m allosaurus.run --model my_english_model --lang eng -i test.wav
```

--------------------------------

### List Available Models - Allosaurus CLI

Source: https://context7.com/xinjli/allosaurus/llms.txt

This command lists all available models, including newly fine-tuned ones, within the Allosaurus system.

```bash
python -m allosaurus.bin.list_model
```

--------------------------------

### Control Phone Generation with Top-K

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Specify the number of top probable phones to generate at each emitting frame. The default value for topk is 1. Higher values provide more options but increase output verbosity.

```bash
# default topk is 1
python -m allosaurus.run -i sample.wav
æ l u s ɔ ɹ s

# output top 5 probable phones at emitting frame, "|" is used to delimit frames (no delimiter when topk=1)
# probability is attached for each phone, the left most phone is the most probable phone 
# <blk> is blank which can be ignored.
python -m allosaurus.run -i sample.wav --topk=5
æ (0.577) ɛ (0.128) ɒ (0.103) a (0.045) ə (0.021) | l (0.754) l̪ (0.196) lː (0.018) ʁ (0.007) ʀ (0.006) | u (0.233) ɨ (0.218) uː (0.104) ɤ (0.070) ɪ (0.066) | s (0.301) <blk> (0.298) z (0.118) s̪ (0.084) sː (0.046) | ɔ (0.454) ɑ (0.251) <blk> (0.105) ɹ̩ (0.062) uə (0.035) | ɹ (0.867) ɾ (0.067) <blk> (0.024) l̪ (0.018) r (0.015) | s (0.740) z (0.191) s̪ (0.039) zʲ (0.009) sː (0.003)
```

--------------------------------

### Transcribe Audio to Phones

Source: https://context7.com/xinjli/allosaurus/llms.txt

Shows how to use the Recognizer.recognize method to convert audio files into IPA phone sequences, including options for timestamps, top-k predictions, and input formats.

```python
from allosaurus.app import read_recognizer
from io import BytesIO

model = read_recognizer()

# Basic recognition
phones = model.recognize('sample.wav')

# Recognition with language inventory and timestamps
phones = model.recognize('sample.wav', lang_id='eng', timestamp=True)

# Top-k predictions
phones = model.recognize('sample.wav', topk=5)

# Process from BytesIO
with open('sample.wav', 'rb') as f:
    audio_bytes = BytesIO(f.read())
phones = model.recognize(audio_bytes)
```

--------------------------------

### Dump Current Phone Inventory to File

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Save the current phone inventory for a specified language to a file. This allows for inspection and customization of the phonetic inventory.

```bash
# dump the phone file
python -m allosaurus.bin.write_phone --lang <language name> --output <a path to save this file>
```

--------------------------------

### List Available Phone Inventories

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Check the current (default) phone inventory for a specified language. This command helps in understanding the available phonetic units for a given language.

```bash
python -m allosaurus.bin.list_phone --lang <language name>
```

--------------------------------

### Run Phone Inference with Allosaurus

Source: https://context7.com/xinjli/allosaurus/llms.txt

Execute phone recognition on audio files using specific models and emission rate adjustments.

```bash
python -m allosaurus.run -i sample.wav --emit 1.2
python -m allosaurus.run -i sample.wav --emit 0.8
python -m allosaurus.run -i sample.wav --model uni2005
```

--------------------------------

### Run Inference with Timestamps

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Demonstrates how to perform phone recognition with timestamp extraction using both the command-line interface and the Python API.

```bash
python -m allosaurus.run --timestamp=True -i sample.wav
```

```python
model = read_recognizer()
model.recognize('./sample.wav', timestamp=True)
```

--------------------------------

### read_audio - Load WAV Audio Files

Source: https://context7.com/xinjli/allosaurus/llms.txt

Loads WAV audio files and returns an Audio object containing samples and metadata. Handles mono/stereo conversion and provides duration information.

```APIDOC
## read_audio - Load WAV Audio Files

### Description
Loads WAV audio files and returns an Audio object with samples and metadata.

### Method
Python Function

### Endpoint
N/A

### Parameters
#### Path Parameters
- **path** (string) - Required - Path to the WAV audio file.
- **channel** (integer) - Optional - The channel to load from stereo audio (0 for left, 1 for right).
- **header_only** (boolean) - Optional - If True, only loads header information without audio data.

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```python
from allosaurus.audio import read_audio, resample_audio

# Load a WAV file
audio = read_audio('sample.wav')

# Access audio properties
print(f"Sample rate: {audio.sample_rate} Hz")
print(f"Duration: {audio.duration():.2f} seconds")
print(f"Sample count: {audio.sample_size}")
print(f"Channels: {audio.channel_number}")

# Load only header information (faster, no audio data)
audio_header = read_audio('sample.wav', header_only=True)
print(f"Audio duration without loading samples: {audio_header.sample_size / audio_header.sample_rate:.2f}s")

# Load specific channel from stereo audio
audio_left = read_audio('stereo.wav', channel=0)
audio_right = read_audio('stereo.wav', channel=1)

# Resample audio to a different sample rate
audio_16k = resample_audio(audio, 16000)
audio_8k = resample_audio(audio, 8000)
```

### Response
#### Success Response (200)
- **Audio object** - An object containing audio samples and metadata.
  - **sample_rate** (integer) - The sample rate of the audio.
  - **sample_size** (integer) - The number of audio samples.
  - **channel_number** (integer) - The number of audio channels.

#### Response Example
```
Sample rate: 16000 Hz
Duration: 1.25 seconds
Sample count: 20000
Channels: 1
```
```

--------------------------------

### read_recognizer - Load Phone Recognition Model

Source: https://context7.com/xinjli/allosaurus/llms.txt

Initializes and returns a Recognizer object configured with acoustic, preprocessing, and language models.

```APIDOC
## Python: read_recognizer

### Description
Initializes the Allosaurus recognizer. It automatically downloads the latest model if not present locally.

### Parameters
- **model_name** (string) - Optional - The specific model identifier (e.g., 'uni2005', 'eng2102').
- **config** (argparse.Namespace) - Optional - Custom configuration object for device_id, language, and model settings.

### Request Example
from allosaurus.app import read_recognizer
model = read_recognizer('uni2005')

### Response
- **Recognizer** (object) - The initialized model instance ready for transcription.
```

--------------------------------

### Customize Phone Inventory

Source: https://context7.com/xinjli/allosaurus/llms.txt

Export, modify, update, and restore phone inventories for specific languages.

```bash
python -m allosaurus.bin.write_phone --lang eng --output english_phones.txt
python -m allosaurus.bin.update_phone --lang eng --input english_phones.txt
python -m allosaurus.bin.list_phone --lang eng
python -m allosaurus.bin.restore_phone --lang eng
python -m allosaurus.bin.write_phone --lang eng --output phones.txt --format kaldi
```

--------------------------------

### List Available Models

Source: https://context7.com/xinjli/allosaurus/llms.txt

Verifies the availability of trained models, including newly fine-tuned ones.

```APIDOC
## List Available Models

### Description
Lists all available models, including custom fine-tuned models.

### Method
Command Line

### Endpoint
N/A

### Parameters
N/A

### Request Example
```bash
python -m allosaurus.bin.list_model
```

### Response
N/A
```

--------------------------------

### Train Fine-Tuned Model - Allosaurus CLI

Source: https://context7.com/xinjli/allosaurus/llms.txt

Fine-tune a pre-trained Allosaurus model on a custom dataset. This process can be customized with various training parameters like learning rate, batch size, and gradient clipping. It also supports CPU training by setting device_id to -1.

```bash
# Fine-tune model with default settings
python -m allosaurus.bin.adapt_model \
    --pretrained_model uni2005 \
    --new_model my_english_model \
    --path /path/to/my_dataset \
    --lang eng \
    --device_id 0 \
    --epoch 10

# Fine-tune with custom training parameters
python -m allosaurus.bin.adapt_model \
    --pretrained_model uni2005 \
    --new_model my_custom_model \
    --path /path/to/my_dataset \
    --lang eng \
    --device_id 0 \
    --epoch 20 \
    --lr 0.005 \
    --batch_frame_size 4000 \
    --grad_clip 5.0 \
    --log training.log

# Use CPU if no GPU available
python -m allosaurus.bin.adapt_model \
    --pretrained_model uni2005 \
    --new_model my_model \
    --path /path/to/my_dataset \
    --lang eng \
    --device_id -1 \
    --epoch 5
```

--------------------------------

### Update Phone Inventory

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Update the model's phone inventory with a customized file. The input file should contain one IPA phone per line. After updating, list_phone will show the new inventory.

```bash
python -m allosaurus.bin.update_phone --lang <language name> --input <the file you customized)
```

--------------------------------

### Audio Class Operations - Allosaurus Python API

Source: https://context7.com/xinjli/allosaurus/llms.txt

Demonstrates operations on the `Audio` class in Allosaurus, including creating an Audio object from a NumPy array, checking its properties, extending it with other audio segments (with automatic resampling), and clearing its data.

```python
from allosaurus.audio import read_audio, Audio
import numpy as np

# Create Audio object from numpy array
samples = np.zeros(16000, dtype='int16')  # 1 second of silence at 16kHz
audio = Audio(samples, sample_rate=16000)

# Check audio properties
print(f"Audio info: {audio}")
# Output: <Audio sample rate: 16000, samples: 16000, second: 1.0 >

print(f"Length: {len(audio)} samples")
print(f"Is empty: {audio.empty()}")

# Extend audio with another audio segment
audio2 = read_audio('another_sample.wav')
audio.extend(audio2)  # Automatically resamples if rates differ

# Clear audio data
audio.clear()
print(f"After clear - Is empty: {audio.empty()}")
```

--------------------------------

### Recognizer.is_available - Check Language Support

Source: https://context7.com/xinjli/allosaurus/llms.txt

Verifies if a specific language ID is supported by the current model's phone inventory.

```APIDOC
## Python: Recognizer.is_available

### Description
Checks if the provided language identifier is supported by the loaded model.

### Parameters
- **lang_id** (string) - Required - The ISO language code to check.

### Request Example
if model.is_available('eng'):
    print('English supported')

### Response
- **is_available** (boolean) - True if supported, False otherwise.
```

--------------------------------

### Read WAV Audio Files - Allosaurus Python API

Source: https://context7.com/xinjli/allosaurus/llms.txt

Load WAV audio files using the `read_audio` function from the `allosaurus.audio` module. This function returns an Audio object with samples and metadata, and supports loading only header information or specific channels from stereo audio. It also includes functionality for resampling audio.

```python
from allosaurus.audio import read_audio, resample_audio

# Load a WAV file
audio = read_audio('sample.wav')

# Access audio properties
print(f"Sample rate: {audio.sample_rate} Hz")
print(f"Duration: {audio.duration():.2f} seconds")
print(f"Sample count: {audio.sample_size}")
print(f"Channels: {audio.channel_number}")

# Output:
# Sample rate: 16000 Hz
# Duration: 1.25 seconds
# Sample count: 20000
# Channels: 1

# Load only header information (faster, no audio data)
audio_header = read_audio('sample.wav', header_only=True)
print(f"Audio duration without loading samples: {audio_header.sample_size / audio_header.sample_rate:.2f}s")

# Load specific channel from stereo audio
audio_left = read_audio('stereo.wav', channel=0)
audio_right = read_audio('stereo.wav', channel=1)

# Resample audio to a different sample rate
audio_16k = resample_audio(audio, 16000)
audio_8k = resample_audio(audio, 8000)
```

--------------------------------

### List Available Languages with Allosaurus

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Lists all supported language identifiers for phone recognition. This command helps users identify the correct language code to improve recognition accuracy.

```bash
python -m allosaurus.bin.list_lang
```

--------------------------------

### Check Language Support

Source: https://context7.com/xinjli/allosaurus/llms.txt

Verifies if a specific language ID is supported by the loaded model's phone inventory.

```python
from allosaurus.app import read_recognizer
model = read_recognizer()

if model.is_available('eng'):
    phones = model.recognize('audio.wav', lang_id='eng')

# Check multiple languages
languages = ['eng', 'cmn', 'spa', 'fra', 'deu', 'jpn']
for lang in languages:
    status = "supported" if model.is_available(lang) else "not found"
    print(f"{lang}: {status}")
```

--------------------------------

### Restore Default Phone Inventory

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Revert to the original phone inventory for a specified language. This action will delete any custom inventory files that were previously registered.

```bash
python -m allosaurus.bin.restore_phone --lang <language name>
```

--------------------------------

### Control Output Length with Silence Prior

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Adjust the number of output phones by modifying the prior score for the '<blk>' (silence) phone. A positive score increases silence (fewer output phones), and a negative score decreases silence (more output phones).

```bash
# <blk> 1.0
python -m allosaurus.run -i=sample.wav --lang=eng --prior=prior.txt 
æ l u ɔ ɹ s

# <blk> -1.0
$ python -m allosaurus.run -i=sample.wav --lang=eng --prior=prior.txt 
æ l u s f ɔ ɹ s
```

--------------------------------

### Allosaurus Python API Inference Options

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Demonstrates the Python API for Allosaurus inference, allowing users to load a specific model and run recognition on an audio file with an optional language specification. The 'latest' model and 'ipa' language are defaults.

```python
from allosaurus.app import read_recognizer

# load your model by the <model name>, will use 'latest' if left empty
model = read_recognizer(model)

# run inference on <audio_file> with <lang>, lang will be 'ipa' if left empty
model.recognize(audio_file, lang)
```

--------------------------------

### List Phone Inventory for a Language

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Displays the phone inventory (phonetic symbols) for a specified language. This is useful for understanding the phone set used by the recognizer for a particular language.

```bash
python -m allosaurus.bin.list_phone [--lang <language name>]
```

```bash
# to get English phone inventory
# ['a', 'aː', 'b', 'd', 'd̠', 'e', 'eː', 'e̞', 'f', 'h', 'i', 'iː', 'j', 'k', 'kʰ', 'l', 'm', 'n', 'o', 'oː', 'p', 'pʰ', 'r', 's', 't', 'tʰ', 't̠', 'u', 'uː', 'v', 'w', 'x', 'z', 'æ', 'ð', 'øː', 'ŋ', 'ɐ', 'ɐː', 'ɑ', 'ɑː', 'ɒ', 'ɒː', 'ɔ', 'ɔː', 'ɘ', 'ə', 'əː', 'ɛ', 'ɛː', 'ɜː', 'ɡ', 'ɪ', 'ɪ̯', 'ɯ', 'ɵː', 'ɹ', 'ɻ', 'ʃ', 'ʉ', 'ʉː', 'ʊ', 'ʌ', 'ʍ', 'ʒ', 'ʔ', 'θ']
python -m allosaurus.bin.list_phone --lang eng
```

--------------------------------

### Adjust Phone Probabilities with Priors

Source: https://context7.com/xinjli/allosaurus/llms.txt

Apply custom prior files to suppress or boost specific phones during inference.

```bash
cat > prior.txt << EOF
æ -10.0
<blk> 1.0
EOF
python -m allosaurus.run -i sample.wav --lang eng --prior prior.txt
```

--------------------------------

### Fine-Tune Allosaurus Models

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Improve model accuracy for specific languages by fine-tuning with custom data. This process adapts the pretrained models to better suit particular linguistic data.

```bash
# Fine-tuning is currently limited to one language at a time.
# Refer to specific fine-tuning documentation for detailed usage.
```

--------------------------------

### Inference with Fine-Tuned Model

Source: https://context7.com/xinjli/allosaurus/llms.txt

Uses a specified fine-tuned model for audio inference.

```APIDOC
## Use the fine-tuned model for inference

### Description
Performs inference on an audio file using a specified model and language.

### Method
Command Line

### Endpoint
N/A

### Parameters
#### Path Parameters
- **--model** (string) - Required - The name of the model to use for inference.
- **--lang** (string) - Required - The language of the audio file.
- **-i** or **--input** (string) - Required - Path to the input audio file.

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```bash
python -m allosaurus.run --model my_english_model --lang eng -i test.wav
```

### Response
N/A
```

--------------------------------

### Audio Class Operations

Source: https://context7.com/xinjli/allosaurus/llms.txt

Provides methods for manipulating audio data including extending, clearing, and checking status.

```APIDOC
## Audio Class Operations

### Description
Provides methods for manipulating audio data within an Audio object.

### Method
Python Class

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
- **samples** (numpy.ndarray) - Required - Numpy array of audio samples.
- **sample_rate** (integer) - Required - The sample rate of the audio.

### Request Example
```python
from allosaurus.audio import read_audio, Audio
import numpy as np

# Create Audio object from numpy array
samples = np.zeros(16000, dtype='int16')  # 1 second of silence at 16kHz
audio = Audio(samples, sample_rate=16000)

# Check audio properties
print(f"Audio info: {audio}")
print(f"Length: {len(audio)} samples")
print(f"Is empty: {audio.empty()}")

# Extend audio with another audio segment
audio2 = read_audio('another_sample.wav')
audio.extend(audio2)  # Automatically resamples if rates differ

# Clear audio data
audio.clear()
print(f"After clear - Is empty: {audio.empty()}")
```

### Response
#### Success Response (200)
- **Audio object** - The modified Audio object.

#### Response Example
```
Audio info: <Audio sample rate: 16000, samples: 16000, second: 1.0 >
Length: 16000 samples
Is empty: False
After clear - Is empty: True
```
```

--------------------------------

### Command Line Phone Recognition

Source: https://context7.com/xinjli/allosaurus/llms.txt

Executes phone recognition tasks directly from the terminal with various configuration flags.

```bash
python -m allosaurus.run -i sample.wav
python -m allosaurus.run -i sample.wav --lang eng
python -m allosaurus.run -i sample.wav --device_id 0
python -m allosaurus.run -i ./audio_directory/ --timestamp=True --topk=5
```

--------------------------------

### Train Fine-Tuned Model

Source: https://context7.com/xinjli/allosaurus/llms.txt

Fine-tune a pretrained model on a custom dataset to improve accuracy for a specific language or domain.

```APIDOC
## Train Fine-Tuned Model

### Description
Fine-tunes a pretrained model on your custom dataset.

### Method
Command Line

### Endpoint
N/A

### Parameters
#### Path Parameters
- **--path** (string) - Required - Path to the custom dataset.

#### Query Parameters
- **--pretrained_model** (string) - Required - The name of the pretrained model to adapt.
- **--new_model** (string) - Required - The name for the newly fine-tuned model.
- **--lang** (string) - Required - The language of the dataset.
- **--device_id** (integer) - Optional - The ID of the GPU device to use (-1 for CPU).
- **--epoch** (integer) - Optional - Number of training epochs.
- **--lr** (float) - Optional - Learning rate for training.
- **--batch_frame_size** (integer) - Optional - Batch size for training.
- **--grad_clip** (float) - Optional - Gradient clipping value.
- **--log** (string) - Optional - File to log training progress.

#### Request Body
N/A

### Request Example
```bash
# Fine-tune model with default settings
python -m allosaurus.bin.adapt_model \
    --pretrained_model uni2005 \
    --new_model my_english_model \
    --path /path/to/my_dataset \
    --lang eng \
    --device_id 0 \
    --epoch 10

# Fine-tune with custom training parameters
python -m allosaurus.bin.adapt_model \
    --pretrained_model uni2005 \
    --new_model my_custom_model \
    --path /path/to/my_dataset \
    --lang eng \
    --device_id 0 \
    --epoch 20 \
    --lr 0.005 \
    --batch_frame_size 4000 \
    --grad_clip 5.0 \
    --log training.log

# Use CPU if no GPU available
python -m allosaurus.bin.adapt_model \
    --pretrained_model uni2005 \
    --new_model my_model \
    --path /path/to/my_dataset \
    --lang eng \
    --device_id -1 \
    --epoch 5
```

### Response
N/A
```

--------------------------------

### Recognizer.recognize - Transcribe Audio

Source: https://context7.com/xinjli/allosaurus/llms.txt

Processes audio files or streams to return a sequence of recognized IPA phones.

```APIDOC
## Python: Recognizer.recognize

### Description
Transcribes audio input into IPA phone sequences. Supports language-specific inventories, timestamps, and probability outputs.

### Parameters
- **audio_path** (string/BytesIO) - Required - Path to WAV file or audio stream.
- **lang_id** (string) - Optional - ISO language code to constrain the phone inventory.
- **timestamp** (boolean) - Optional - If True, returns start time and duration for each phone.
- **topk** (int) - Optional - Returns top-k phone predictions with probabilities.
- **emit** (float) - Optional - Controls the emission rate of phones.

### Request Example
phones = model.recognize('sample.wav', lang_id='eng', timestamp=True)

### Response
- **result** (string) - The sequence of recognized phones or detailed output including timestamps/probabilities.
```

--------------------------------

### Extract text tokens for validation set

Source: https://context7.com/xinjli/allosaurus/llms.txt

This command extracts text tokens from a dataset for use in a validation set, utilizing a specified model and language.

```APIDOC
## Extract text tokens for validation set

### Description
Extracts text tokens from a dataset for validation purposes.

### Method
Command Line

### Endpoint
N/A

### Parameters
#### Path Parameters
- **--path** (string) - Required - Path to the dataset directory.

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```bash
python -m allosaurus.bin.prep_token --model uni2005 --lang eng --path /path/to/my_dataset/validate
```

### Response
N/A
```

--------------------------------

### Extract Text Tokens for Validation Set - Allosaurus CLI

Source: https://context7.com/xinjli/allosaurus/llms.txt

This command extracts text tokens from a dataset for validation purposes using the Allosaurus CLI. It requires specifying the model, language, and dataset path.

```bash
python -m allosaurus.bin.prep_token --model uni2005 --lang eng --path /path/to/my_dataset/validate
```

--------------------------------

### Control Phone Emission Count

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Adjust the number of phones emitted by the model using the `--emit` or `-e` argument. Values greater than 1 emit more phones, while values less than 1 emit fewer phones. The default emit value is 1.0.

```bash
# default emit is 1.0
python -m allosaurus.run -i sample.wav 
æ l u s ɔ ɹ s

# emit more phones when emit > 1
python -m allosaurus.run -e 1.2 -i sample.wav 
æ l u s f h ɔ ɹ s

# emit less phones when emit < 1
python -m allosaurus.run -e 0.8 -i sample.wav 
æ l u ɹ s
```

--------------------------------

### Adjust Phone Prior Probabilities

Source: https://github.com/xinjli/allosaurus/blob/master/README.md

Modify the prior probability of phones to influence generation results. Positive scores boost prediction, negative scores suppress it. This can be used to reduce unwanted phones or increase desired ones.

```bash
python -m allosaurus.run -i=sample.wav --lang=eng --prior=prior.txt
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.