onnxcrepe

https://github.com/yqzhishen/onnxcrepe
Admin
ONNX deployment of the CREPE pitch tracker, a convolutional neural network model for accurate pitch...
Tokens:10,053
Snippets:50
Trust Score:7.9
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### onnxcrepe Configuration File Format

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Example JSON structure for custom configuration files used with onnxcrepe. Allows customization of model, precision, batch size, padding, frequency range, decoder, thresholding, and execution providers.

```json
{
  "model": "full",
  "precision": 5.0,
  "batch_size": 512,
  "pad": true,
  "fmin": 50.0,
  "fmax": 1100.0,
  "decoder": "weighted_viterbi",
  "threshold": {
    "type": "hard",
    "arguments": {
      "at": 0.21
    }
  },
  "providers": [
    {
      "name": "CUDAExecutionProvider",
      "options": {
        "device_id": 0,
        "cudnn_conv_algo_search": "DEFAULT"
      }
    },
    {
      "name": "DmlExecutionProvider",
      "options": {
        "device_id": 0
      }
    },
    {
      "name": "CPUExecutionProvider",
      "options": {}
    }
  ]
}
```

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

### onnxcrepe Command-Line Interface Examples

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Demonstrates various ways to use the onnxcrepe command-line interface for batch processing audio files. Supports single file, multiple files, output directory specification, saving periodicity, different output formats, custom configurations, and directory processing with glob patterns.

```bash
# Basic usage - process single file
python -m onnxcrepe audio.wav
```

```bash
# Process multiple files
python -m onnxcrepe file1.wav file2.wav file3.wav
```

```bash
# Specify output directory
python -m onnxcrepe audio.wav --output_directory ./results
```

```bash
# Save periodicity values
python -m onnxcrepe audio.wav --save_periodicity
```

```bash
# Output as NumPy arrays instead of CSV
python -m onnxcrepe audio.wav --format npy
```

```bash
# Use custom configuration file
python -m onnxcrepe audio.wav --config my_config.json
```

```bash
# Process directory of files with glob
python -m onnxcrepe *.wav --output_directory ./pitch_results --save_periodicity
```

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

### ONNX CREPE Command-Line Interface

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Provides command-line tools for batch processing audio files with ONNX CREPE.

```APIDOC
## Command-Line Interface

### Description
ONNX CREPE can be run as a module from the command line for batch processing.

### Usage Examples

#### Basic usage - process single file
```bash
python -m onnxcrepe audio.wav
```

#### Process multiple files
```bash
python -m onnxcrepe file1.wav file2.wav file3.wav
```

#### Specify output directory
```bash
python -m onnxcrepe audio.wav --output_directory ./results
```

#### Save periodicity values
```bash
python -m onnxcrepe audio.wav --save_periodicity
```

#### Output as NumPy arrays instead of CSV
```bash
python -m onnxcrepe audio.wav --format npy
```

#### Use custom configuration file
```bash
python -m onnxcrepe audio.wav --config my_config.json
```

#### Process directory of files with glob
```bash
python -m onnxcrepe *.wav --output_directory ./pitch_results --save_periodicity
```
```

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

### Batch Process Audio Files with Progress Bar

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Processes multiple audio files in a directory, displays a progress bar, and saves the results. Ensure the output directory exists.

```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession
import glob

session = CrepeInferenceSession(model='full')

# Process all WAV files in a directory
audio_files = glob.glob('./audio/*.wav')

onnxcrepe.predict_from_files_to_files(
    session,
    audio_files,
    output_directory='./pitch_output',
    save_periodicity=True,
    format='csv',
    precision=10.0,
    fmin=50.,
    fmax=1000.,
    batch_size=512
)
# Progress bar: onnxcrepe: 100%|████████| 50/50 [00:45<00:00, 1.10it/s]
```

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

### CrepeInferenceSession Initialization

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Initializes an ONNX inference session for the CREPE model. This is the main entry point for loading the pitch estimation model with specified capacity and execution providers.

```APIDOC
## CrepeInferenceSession

### Description
Creates an ONNX inference session for the CREPE model. This is the main entry point for loading the pitch estimation model with specified capacity and execution providers.

### Method
`CrepeInferenceSession(model, providers, sess_options)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

# Create session with GPU acceleration (falls back to CPU if unavailable)
session = CrepeInferenceSession(
    model='full',  # Options: 'full', 'large', 'medium', 'small', 'tiny'
    providers=['CUDAExecutionProvider', 'DmlExecutionProvider', 'CPUExecutionProvider']
)

# Create session with custom ONNX Runtime options
import onnxruntime as ort
options = ort.SessionOptions()
options.enable_mem_pattern = False  # Required for DirectML
options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL

session = CrepeInferenceSession(
    model='tiny',  # Faster, smaller model
    sess_options=options,
    providers=[('CUDAExecutionProvider', {'device_id': 0})]
)

# Clean up when done
del session
```

### Response
None (object is created and assigned to a variable)

#### Success Response (200)
None

#### Response Example
None
```

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

### Create ONNX Inference Session

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Initializes an ONNX inference session for the CREPE model. Specify model capacity and execution providers for hardware acceleration. Custom ONNX Runtime options can also be provided.

```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

# Create session with GPU acceleration (falls back to CPU if unavailable)
session = CrepeInferenceSession(
    model='full',  # Options: 'full', 'large', 'medium', 'small', 'tiny'
    providers=['CUDAExecutionProvider', 'DmlExecutionProvider', 'CPUExecutionProvider']
)
```

```python
import onnxruntime as ort
options = ort.SessionOptions()
options.enable_mem_pattern = False  # Required for DirectML
options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL

session = CrepeInferenceSession(
    model='tiny',  # Faster, smaller model
    sess_options=options,
    providers=[('CUDAExecutionProvider', {'device_id': 0})]
)
```

```python
# Clean up when done
del session
```

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

### Pitch Decoding Methods Comparison

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Compares different decoding strategies for converting model output probabilities to pitch values, ranging from fastest to highest quality. Each method offers a different trade-off between speed and accuracy.

```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')
audio, sr = onnxcrepe.load.audio('audio.wav')

# argmax: Fastest, takes most likely pitch bin
pitch_argmax = onnxcrepe.predict(
    session, audio, sr,
    decoder=onnxcrepe.decode.argmax
)

# weighted_argmax: Weighted average around argmax for sub-bin precision
pitch_weighted = onnxcrepe.predict(
    session, audio, sr,
    decoder=onnxcrepe.decode.weighted_argmax
)

# viterbi: Temporal smoothing using Viterbi algorithm
pitch_viterbi = onnxcrepe.predict(
    session, audio, sr,
    decoder=onnxcrepe.decode.viterbi
)

# weighted_viterbi: Best quality, combines Viterbi + weighted averaging (default)
pitch_best = onnxcrepe.predict(
    session, audio, sr,
    decoder=onnxcrepe.decode.weighted_viterbi
)
```

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

### Load Audio and Compute A-weighted Loudness

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Loads an audio file and computes its A-weighted loudness per frame. Useful for silence detection and voice activity estimation. Ensure the audio file exists.

```python
import onnxcrepe

audio, sr = onnxcrepe.load.audio('audio.wav')

# Compute A-weighted loudness in dB
loudness = onnxcrepe.loudness.a_weighted(
    audio,
    sample_rate=sr,
    hop_length=sr // 100,  # 10ms frames
    pad=True
)
# Output: numpy.ndarray, shape (1, num_frames)
# Values in dB, typical range: -100 to 0

# Use for silence detection
silence_mask = loudness < -60  # -60 dB threshold
```

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

### Predict Pitch Directly from Audio File

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Loads audio from disk and performs pitch estimation in a single call using librosa for file loading. Supports various audio formats and allows specifying prediction parameters.

```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')

# Predict pitch directly from audio file
pitch = onnxcrepe.predict_from_file(
    session,
    'recording.wav',
    precision=10.0,
    fmin=50.,
    fmax=500.,  # Good range for speech
    decoder=onnxcrepe.decode.viterbi,
    batch_size=512
)
```

```python
# With periodicity for voice activity detection
pitch, periodicity = onnxcrepe.predict_from_file(
    session,
    'vocals.mp3',  # Supports any format librosa can load
    precision=5.0,
    fmin=80.,
    fmax=1000.,
    return_periodicity=True
)
```

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

### Load Audio File

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Loads an audio file from disk using librosa. The function automatically handles conversion to mono if the input audio is stereo.

```python
import onnxcrepe

# Load audio file (supports WAV, MP3, FLAC, etc.)
audio, sample_rate = onnxcrepe.load.audio('recording.wav')
# audio: numpy.ndarray with shape (num_samples,)
```

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

### Audio Loading

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Loads audio files from disk using the librosa library. The function automatically handles resampling and converts the audio to mono if it is stereo.

```APIDOC
## POST /load/audio

### Description
Loads audio from disk using librosa, automatically converting to mono if necessary.

### Method
POST

### Endpoint
/load/audio

### Parameters
#### Path Parameters
- **file_path** (str) - Required - The path to the audio file (supports WAV, MP3, FLAC, etc.).

### Request Example
```python
import onnxcrepe

# Load audio file (supports WAV, MP3, FLAC, etc.)
audio, sample_rate = onnxcrepe.load.audio('recording.wav')
# audio: numpy.ndarray with shape (num_samples,)
```

### Response
#### Success Response (200)
- **audio** (numpy.ndarray) - The audio time series as a NumPy array.
- **sample_rate** (int) - The sampling rate of the audio.
```

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

### onnxcrepe.predict_from_file

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Loads audio from disk and performs pitch estimation in a single call. Handles file loading internally using librosa.

```APIDOC
## onnxcrepe.predict_from_file

### Description
Loads audio from disk and performs pitch estimation in a single call. Handles file loading internally using librosa.

### Method
`onnxcrepe.predict_from_file(session, audio_path, precision, fmin, fmax, decoder, return_periodicity, batch_size)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')

# Predict pitch directly from audio file
pitch = onnxcrepe.predict_from_file(
    session,
    'recording.wav',
    precision=10.0,
    fmin=50.,
    fmax=500.,  # Good range for speech
    decoder=onnxcrepe.decode.viterbi,
    batch_size=512
)

# With periodicity for voice activity detection
pitch, periodicity = onnxcrepe.predict_from_file(
    session,
    'vocals.mp3',  # Supports any format librosa can load
    precision=5.0,
    fmin=80.,
    fmax=1000.,
    return_periodicity=True
)
```

### Response
#### Success Response (200)
- **pitch** (numpy.ndarray) - Array of frequencies in Hz.
- **periodicity** (numpy.ndarray, optional) - Array of confidence values (0.0 to 1.0).

#### Response Example
```json
{
  "pitch": [[220.5, 221.2, 222.0, null, null, 225.1, ...]]
}
```

```json
{
  "pitch": [[220.5, 221.2, 222.0, null, null, 225.1, ...]],
  "periodicity": [[0.8, 0.85, 0.9, 0.1, 0.1, 0.92, ...]]
}
```
```

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

### ONNX CREPE Configuration File Format

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Defines the structure for custom JSON configuration files used with ONNX CREPE.

```APIDOC
## Configuration File Format

### Description
Custom configurations can be specified via JSON files placed in the configs directory or referenced by path.

### Structure
```json
{
  "model": "full",
  "precision": 5.0,
  "batch_size": 512,
  "pad": true,
  "fmin": 50.0,
  "fmax": 1100.0,
  "decoder": "weighted_viterbi",
  "threshold": {
    "type": "hard",
    "arguments": {
      "at": 0.21
    }
  },
  "providers": [
    {
      "name": "CUDAExecutionProvider",
      "options": {
        "device_id": 0,
        "cudnn_conv_algo_search": "DEFAULT"
      }
    },
    {
      "name": "DmlExecutionProvider",
      "options": {
        "device_id": 0
      }
    },
    {
      "name": "CPUExecutionProvider",
      "options": {}
    }
  ]
}
```

### Fields
- **model** (string) - Specifies the model to use (e.g., "full").
- **precision** (float) - Precision setting for the model.
- **batch_size** (integer) - Batch size for processing.
- **pad** (boolean) - Whether to pad the audio.
- **fmin** (float) - Minimum frequency.
- **fmax** (float) - Maximum frequency.
- **decoder** (string) - The decoder to use (e.g., "weighted_viterbi").
- **threshold** (object) - Thresholding configuration.
  - **type** (string) - Type of thresholding (e.g., "hard").
  - **arguments** (object) - Arguments for the thresholding type.
    - **at** (float) - Threshold value.
- **providers** (array) - List of execution providers.
  - **name** (string) - Name of the execution provider (e.g., "CUDAExecutionProvider").
  - **options** (object) - Options for the execution provider.
    - **device_id** (integer) - Device ID.
    - **cudnn_conv_algo_search** (string) - cuDNN convolution algorithm search setting.
```

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

### onnxcrepe.predict_from_file_to_file

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Processes audio files and saves pitch results directly to disk in CSV or NPY format.

```APIDOC
## onnxcrepe.predict_from_file_to_file

### Description
Processes audio files and saves pitch results directly to disk in CSV or NPY format.

### Method
`onnxcrepe.predict_from_file_to_file(session, input_path, output_directory, save_periodicity, format, precision, fmin, fmax)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')

# Save results as CSV (time, f0, [periodicity])
onnxcrepe.predict_from_file_to_file(
    session,
    'input.wav',
    output_directory='./results',
    save_periodicity=True,
    format='csv',  # Creates: results/input.pitch.csv
    precision=10.0,
    fmin=50.,
    fmax=800.
)
# CSV output format: "0.000000,220.123456,0.892345"

# Save results as NumPy arrays
onnxcrepe.predict_from_file_to_file(
    session,
    'input.wav',
    output_directory='./results',
    save_periodicity=True,
    format='npy',  # Creates: results/input.f0.npy, results/input.periodicity.npy
    precision=5.0
)
```

### Response
None (results are saved to files)

#### Success Response (200)
None

#### Response Example
None
```

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

### Pitch Decoding Methods

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Explores different decoding strategies to convert model output probabilities into pitch values. These methods offer a trade-off between processing speed and accuracy.

```APIDOC
## POST /decode

### Description
Provides different decoding strategies to convert model output probabilities to pitch values. Decoders trade off between speed and accuracy.

### Method
POST

### Endpoint
/decode

### Parameters
#### Path Parameters
- **session** (CrepeInferenceSession) - Required - The inference session object.
- **audio** (numpy.ndarray) - Required - The audio time series.
- **sr** (int) - Required - The sampling rate of the audio.
- **decoder** (function) - Optional - The decoding function to use. Defaults to `onnxcrepe.decode.weighted_viterbi`.

### Request Example
```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')
audio, sr = onnxcrepe.load.audio('audio.wav')

# argmax: Fastest, takes most likely pitch bin
pitch_argmax = onnxcrepe.predict(
    session, audio, sr,
    decoder=onnxcrepe.decode.argmax
)

# weighted_argmax: Weighted average around argmax for sub-bin precision
pitch_weighted = onnxcrepe.predict(
    session, audio, sr,
    decoder=onnxcrepe.decode.weighted_argmax
)

# viterbi: Temporal smoothing using Viterbi algorithm
pitch_viterbi = onnxcrepe.predict(
    session, audio, sr,
    decoder=onnxcrepe.decode.viterbi
)

# weighted_viterbi: Best quality, combines Viterbi + weighted averaging (default)
pitch_best = onnxcrepe.predict(
    session, audio, sr,
    decoder=onnxcrepe.decode.weighted_viterbi
)
```

### Response
#### Success Response (200)
- **pitch** (numpy.ndarray) - The predicted pitch values.
```

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

### Process Audio Files and Save Pitch Results

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Processes audio files and saves pitch estimation results directly to disk in CSV or NPY format. Supports saving periodicity values and configuring output format and parameters.

```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')

# Save results as CSV (time, f0, [periodicity])
onnxcrepe.predict_from_file_to_file(
    session,
    'input.wav',
    output_directory='./results',
    save_periodicity=True,
    format='csv',  # Creates: results/input.pitch.csv
    precision=10.0,
    fmin=50.,
    fmax=800.
)
```

```python
# CSV output format: "0.000000,220.123456,0.892345"

# Save results as NumPy arrays
onnxcrepe.predict_from_file_to_file(
    session,
    'input.wav',
    output_directory='./results',
    save_periodicity=True,
    format='npy',  # Creates: results/input.f0.npy, results/input.periodicity.npy
    precision=5.0
)
```

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

### Predict Pitch from Audio Data

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Performs pitch estimation on audio data loaded into memory. Returns pitch values in Hz and optionally periodicity (confidence) values. Configure precision, frequency range, decoder, and batch size for performance.

```python
import numpy as np
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

# Load audio (16-bit WAV, any sample rate)
audio, sr = onnxcrepe.load.audio('speech.wav')

# Create inference session
session = CrepeInferenceSession(model='full')

# Basic pitch prediction with default settings
# Returns: numpy.ndarray with shape (1, num_frames)
pitch = onnxcrepe.predict(
    session,
    audio,
    sr,
    precision=10.0,  # Frame length in milliseconds
    fmin=50.,        # Minimum frequency in Hz
    fmax=2006.,      # Maximum frequency in Hz (upper limit)
    batch_size=512   # Frames per batch for memory management
)
```

```python
# Prediction with periodicity (confidence) values
pitch, periodicity = onnxcrepe.predict(
    session,
    audio,
    sr,
    precision=5.0,
    fmin=80.,
    fmax=800.,
    decoder=onnxcrepe.decode.weighted_viterbi,  # Best quality
    return_periodicity=True,
    batch_size=1024,
    pad=True  # Zero-pad audio edges
)
```

```python
# Output: pitch array in Hz, shape (1, num_frames)
# Example: [[220.5, 221.2, 222.0, nan, nan, 225.1, ...]]

# pitch: array of frequencies in Hz
# periodicity: array of confidence values (0.0 to 1.0)
print(f"Pitch shape: {pitch.shape}")
print(f"Mean pitch: {np.nanmean(pitch)} Hz")
print(f"Mean confidence: {np.mean(periodicity)}")
```

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

### Print Audio Duration and Sample Rate

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Prints the duration of an audio signal in seconds and its sample rate in Hz. Assumes 'audio' is a NumPy array and 'sample_rate' is an integer.

```python
print(f"Duration: {len(audio) / sample_rate:.2f} seconds")
print(f"Sample rate: {sample_rate} Hz")
```

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

### Unit Conversions

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Provides utility functions for converting pitch values between different units, including Hertz (Hz), cents, and pitch bins. These conversions are essential for interpreting and manipulating pitch data.

```APIDOC
## POST /convert

### Description
Provides conversion functions between frequency units: Hz, cents, and pitch bins.

### Method
POST

### Endpoint
/convert

### Parameters
#### Query Parameters
- **unit_from** (str) - Required - The unit to convert from ('hz', 'cents', 'bins').
- **unit_to** (str) - Required - The unit to convert to ('hz', 'cents', 'bins').
- **value** (float or list[float]) - Required - The value(s) to convert.

### Request Example
```python
import numpy as np
import onnxcrepe

# Frequency (Hz) to cents
freq = np.array([220.0, 440.0, 880.0])
cents = onnxcrepe.convert.frequency_to_cents(freq)
# Output: [5700., 6900., 8100.] cents (relative to 10 Hz)

# Cents to frequency (Hz)
freq_back = onnxcrepe.convert.cents_to_frequency(cents)
# Output: [220., 440., 880.] Hz

# Frequency to pitch bins (0-359)
bins = onnxcrepe.convert.frequency_to_bins(freq)
# Output: [185, 245, 305] (integer bin indices)

# Pitch bins to frequency
freq_from_bins = onnxcrepe.convert.bins_to_frequency(bins)
# Output: approximate frequencies

# Bins to cents (with optional dithering to reduce quantization noise)
cents_dithered = onnxcrepe.convert.bins_to_cents(bins, apply_dither=True)
```

### Response
#### Success Response (200)
- **converted_value** (float or list[float]) - The converted value(s) in the target unit.
```

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

### onnxcrepe Constants

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Prints key constants used within the onnxcrepe library for audio processing, pitch range, and unvoiced frame marking. These constants define internal parameters and conventions.

```python
import onnxcrepe

# Audio processing constants
print(onnxcrepe.SAMPLE_RATE)   # 16000 Hz - internal sample rate
print(onnxcrepe.WINDOW_SIZE)   # 1024 samples - analysis window

# Pitch range constants
print(onnxcrepe.PITCH_BINS)    # 360 - number of pitch bins
print(onnxcrepe.CENTS_PER_BIN) # 20 cents per bin
print(onnxcrepe.MAX_FMAX)      # 2006.0 Hz - maximum detectable frequency

# Unvoiced marker
print(onnxcrepe.UNVOICED)      # np.nan - value for unvoiced frames
```

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

### Frequency Unit Conversions

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Provides functions to convert between different frequency units: Hertz (Hz), cents, and pitch bins. These conversions are useful for interpreting and manipulating pitch data.

```python
import numpy as np
import onnxcrepe

# Frequency (Hz) to cents
freq = np.array([220.0, 440.0, 880.0])
cents = onnxcrepe.convert.frequency_to_cents(freq)
# Output: [5700., 6900., 8100.] cents (relative to 10 Hz)

# Cents to frequency (Hz)
freq_back = onnxcrepe.convert.cents_to_frequency(cents)
# Output: [220., 440., 880.] Hz

# Frequency to pitch bins (0-359)
bins = onnxcrepe.convert.frequency_to_bins(freq)
# Output: [185, 245, 305] (integer bin indices)

# Pitch bins to frequency
freq_from_bins = onnxcrepe.convert.bins_to_frequency(bins)
# Output: approximate frequencies

# Bins to cents (with optional dithering to reduce quantization noise)
cents_dithered = onnxcrepe.convert.bins_to_cents(bins, apply_dither=True)
```

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

### Batch Processing Audio Files

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Processes multiple audio files in batches, displays a progress bar, and saves the pitch prediction results for each file. This function is useful for large-scale audio analysis.

```APIDOC
## POST /predict_from_files_to_files

### Description
Batch processes multiple audio files with a progress bar, saving results for each file.

### Method
POST

### Endpoint
/predict_from_files_to_files

### Parameters
#### Query Parameters
- **session** (CrepeInferenceSession) - Required - The inference session object.
- **audio_files** (list[str]) - Required - A list of paths to the audio files to process.
- **output_directory** (str) - Required - The directory where the results will be saved.
- **save_periodicity** (bool) - Optional - Whether to save periodicity information.
- **format** (str) - Optional - The output format for the results (e.g., 'csv').
- **precision** (float) - Optional - The precision for pitch estimation.
- **fmin** (float) - Optional - The minimum frequency to consider.
- **fmax** (float) - Optional - The maximum frequency to consider.
- **batch_size** (int) - Optional - The batch size for processing.

### Request Example
```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession
import glob

session = CrepeInferenceSession(model='full')

# Process all WAV files in a directory
audio_files = glob.glob('./audio/*.wav')

onnxcrepe.predict_from_files_to_files(
    session,
    audio_files,
    output_directory='./pitch_output',
    save_periodicity=True,
    format='csv',
    precision=10.0,
    fmin=50.,
    fmax=1000.,
    batch_size=512
)
```

### Response
#### Success Response (200)
- **None** - The function saves results to files and does not return a value directly.

#### Response Example
```
# Progress bar: onnxcrepe: 100%|████████| 50/50 [00:45<00:00, 1.10it/s]
```
```

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

### ONNX CREPE Constants

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Key constants used throughout the ONNX CREPE library for configuration and calculations.

```APIDOC
## Constants

### Description
Key constants used throughout the library for configuration and calculations.

### Usage Example
```python
import onnxcrepe
import numpy as np

# Audio processing constants
print(f"Internal sample rate: {onnxcrepe.SAMPLE_RATE} Hz")   # 16000 Hz
print(f"Analysis window size: {onnxcrepe.WINDOW_SIZE} samples")   # 1024 samples

# Pitch range constants
print(f"Number of pitch bins: {onnxcrepe.PITCH_BINS}")    # 360
print(f"Cents per bin: {onnxcrepe.CENTS_PER_BIN}") # 20 cents per bin
print(f"Maximum detectable frequency: {onnxcrepe.MAX_FMAX} Hz")      # 2006.0 Hz

# Unvoiced marker
print(f"Unvoiced marker: {onnxcrepe.UNVOICED}")      # np.nan
```

### Constants Overview
- **SAMPLE_RATE** (integer): Internal sample rate used by the library (16000 Hz).
- **WINDOW_SIZE** (integer): The size of the analysis window in samples (1024).
- **PITCH_BINS** (integer): The number of pitch bins used for frequency representation (360).
- **CENTS_PER_BIN** (float): The number of cents represented by each pitch bin (20.0).
- **MAX_FMAX** (float): The maximum frequency that can be detected (2006.0 Hz).
- **UNVOICED** (numpy.float64): A value representing unvoiced frames (np.nan).
```

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

### ONNX CREPE Loudness API

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Computes A-weighted loudness per frame for silence detection and voice activity estimation.

```APIDOC
## onnxcrepe.loudness.a_weighted

### Description
Computes A-weighted loudness per frame for silence detection and voice activity estimation.

### Method
`a_weighted`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
import onnxcrepe

audio, sr = onnxcrepe.load.audio('audio.wav')

loudness = onnxcrepe.loudness.a_weighted(
    audio,
    sample_rate=sr,
    hop_length=sr // 100,  # 10ms frames
    pad=True
)
```

### Response
#### Success Response (200)
- **loudness** (numpy.ndarray) - Output numpy.ndarray with shape (1, num_frames). Values are in dB, typically ranging from -100 to 0.

#### Response Example
```json
{
  "loudness": "numpy.ndarray"
}
```

### Usage Example
```python
# Use for silence detection
silence_mask = loudness < -60  # -60 dB threshold
```
```

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

### Pitch Thresholding for Reliability

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Filters pitch predictions based on periodicity confidence. Supports simple thresholding to set low-confidence pitches to NaN, and hysteresis-based filtering for more robust removal of unreliable estimates.

```python
import numpy as np
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')
audio, sr = onnxcrepe.load.audio('speech.wav')

# Get pitch with periodicity
pitch, periodicity = onnxcrepe.predict(
    session, audio, sr,
    return_periodicity=True
)

# Simple threshold: Set pitch to NaN where confidence < threshold
threshold_fn = onnxcrepe.threshold.At(value=0.21)
pitch_filtered = threshold_fn(pitch, periodicity)
# Result: Low-confidence frames become np.nan

# Hysteresis thresholding: More robust filtering
# Prevents short, unconfident voiced regions
hysteresis_fn = onnxcrepe.threshold.Hysteresis(
    lower_bound=0.19,   # Minimum confidence to consider voiced
    upper_bound=0.31,   # Confidence to confirm voiced region
    width=0.2,          # Parabola width for pitch-dependent threshold
    stds=1.7            # Standard deviations for outlier handling
)
pitch_hysteresis = hysteresis_fn(pitch, periodicity)

# Silence-based periodicity zeroing
silence_fn = onnxcrepe.threshold.Silence(value=-60)  # dB threshold
periodicity_filtered = silence_fn(
    periodicity,
    audio,
    sample_rate=sr,
    precision=10.0,
    pad=True
)
```

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

### onnxcrepe.predict

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Performs pitch estimation on audio data loaded into memory. Returns pitch values in Hz for each frame, optionally with periodicity (confidence) values.

```APIDOC
## onnxcrepe.predict

### Description
Performs pitch estimation on audio data loaded into memory. Returns pitch values in Hz for each frame, optionally with periodicity (confidence) values.

### Method
`onnxcrepe.predict(session, audio, sr, precision, fmin, fmax, decoder, return_periodicity, batch_size, pad)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
import numpy as np
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

# Load audio (16-bit WAV, any sample rate)
audio, sr = onnxcrepe.load.audio('speech.wav')

# Create inference session
session = CrepeInferenceSession(model='full')

# Basic pitch prediction with default settings
# Returns: numpy.ndarray with shape (1, num_frames)
pitch = onnxcrepe.predict(
    session,
    audio,
    sr,
    precision=10.0,  # Frame length in milliseconds
    fmin=50.,        # Minimum frequency in Hz
    fmax=2006.,      # Maximum frequency in Hz (upper limit)
    batch_size=512   # Frames per batch for memory management
)
# Output: pitch array in Hz, shape (1, num_frames)
# Example: [[220.5, 221.2, 222.0, nan, nan, 225.1, ...]]

# Prediction with periodicity (confidence) values
pitch, periodicity = onnxcrepe.predict(
    session,
    audio,
    sr,
    precision=5.0,
    fmin=80.,
    fmax=800.,
    decoder=onnxcrepe.decode.weighted_viterbi,  # Best quality
    return_periodicity=True,
    batch_size=1024,
    pad=True  # Zero-pad audio edges
)
# pitch: array of frequencies in Hz
# periodicity: array of confidence values (0.0 to 1.0)
print(f"Pitch shape: {pitch.shape}")
print(f"Mean pitch: {np.nanmean(pitch)} Hz")
print(f"Mean confidence: {np.mean(periodicity)}")
```

### Response
#### Success Response (200)
- **pitch** (numpy.ndarray) - Array of frequencies in Hz.
- **periodicity** (numpy.ndarray, optional) - Array of confidence values (0.0 to 1.0).

#### Response Example
```json
{
  "pitch": [[220.5, 221.2, 222.0, null, null, 225.1, ...]]
}
```

```json
{
  "pitch": [[220.5, 221.2, 222.0, null, null, 225.1, ...]],
  "periodicity": [[0.8, 0.85, 0.9, 0.1, 0.1, 0.92, ...]]
}
```
```

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

### Pitch Thresholding

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Filters pitch predictions based on periodicity confidence to remove unreliable estimates. Supports simple thresholding and hysteresis-based filtering for more robust results.

```APIDOC
## POST /threshold

### Description
Filters pitch predictions based on periodicity confidence to remove unreliable estimates. Supports simple thresholding and hysteresis-based filtering.

### Method
POST

### Endpoint
/threshold

### Parameters
#### Path Parameters
- **session** (CrepeInferenceSession) - Required - The inference session object.
- **audio** (str) - Required - Path to the audio file.
- **return_periodicity** (bool) - Optional - Whether to return periodicity along with pitch.

#### Request Body
- **threshold_fn** (function) - Required - The thresholding function to apply (e.g., `onnxcrepe.threshold.At`, `onnxcrepe.threshold.Hysteresis`, `onnxcrepe.threshold.Silence`).

### Request Example
```python
import numpy as np
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')
audio, sr = onnxcrepe.load.audio('speech.wav')

# Get pitch with periodicity
pitch, periodicity = onnxcrepe.predict(
    session, audio, sr,
    return_periodicity=True
)

# Simple threshold: Set pitch to NaN where confidence < threshold
threshold_fn = onnxcrepe.threshold.At(value=0.21)
pitch_filtered = threshold_fn(pitch, periodicity)
# Result: Low-confidence frames become np.nan

# Hysteresis thresholding: More robust filtering
# Prevents short, unconfident voiced regions
hysteresis_fn = onnxcrepe.threshold.Hysteresis(
    lower_bound=0.19,
    upper_bound=0.31,
    width=0.2,
    stds=1.7
)
pitch_hysteresis = hysteresis_fn(pitch, periodicity)

# Silence-based periodicity zeroing
silence_fn = onnxcrepe.threshold.Silence(value=-60)  # dB threshold
periodicity_filtered = silence_fn(
    periodicity,
    audio,
    sample_rate=sr,
    precision=10.0,
    pad=True
)
```

### Response
#### Success Response (200)
- **pitch_filtered** (numpy.ndarray) - Filtered pitch predictions.
- **periodicity_filtered** (numpy.ndarray) - Filtered periodicity values.
```

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

### Signal Filtering for Pitch Sequences

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Applies mean or median filtering to pitch sequences, effectively smoothing the data or removing outliers. These filters are designed to handle NaN values present in unvoiced regions.

```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')
audio, sr = onnxcrepe.load.audio('audio.wav')

pitch = onnxcrepe.predict(session, audio, sr)

# Mean filtering (smoothing) - ignores NaN values
pitch_smoothed = onnxcrepe.filter.mean(
    pitch,
    win_length=9  # Window size in frames
)

# Median filtering (removes outliers) - ignores NaN values
pitch_median = onnxcrepe.filter.median(
    pitch,
    win_length=5
)
```

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

### Signal Filtering

Source: https://context7.com/yqzhishen/onnxcrepe/llms.txt

Applies mean or median filtering to pitch sequences. These filters help smooth the pitch contour and remove outliers, while correctly handling NaN values for unvoiced segments.

```APIDOC
## POST /filter

### Description
Applies mean or median filtering to pitch sequences while handling NaN values for unvoiced regions.

### Method
POST

### Endpoint
/filter

### Parameters
#### Path Parameters
- **session** (CrepeInferenceSession) - Required - The inference session object.
- **audio** (str) - Required - Path to the audio file.

#### Request Body
- **filter_type** (str) - Required - Type of filter to apply ('mean' or 'median').
- **win_length** (int) - Required - Window size in frames for the filter.

### Request Example
```python
import onnxcrepe
from onnxcrepe.session import CrepeInferenceSession

session = CrepeInferenceSession(model='full')
audio, sr = onnxcrepe.load.audio('audio.wav')

pitch = onnxcrepe.predict(session, audio, sr)

# Mean filtering (smoothing) - ignores NaN values
pitch_smoothed = onnxcrepe.filter.mean(
    pitch,
    win_length=9  # Window size in frames
)

# Median filtering (removes outliers) - ignores NaN values
pitch_median = onnxcrepe.filter.median(
    pitch,
    win_length=5
)
```

### Response
#### Success Response (200)
- **pitch_smoothed** (numpy.ndarray) - Smoothed pitch values.
- **pitch_median** (numpy.ndarray) - Median filtered pitch values.
```
Tokens:
Raw