### Install PyAudio Wheel File

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Install the PyAudio wheel file locally if automatic installation fails, especially on Windows.

```bash
pip install <Pyaduio_file_name.whl>
```

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

### Start BeatNet Training

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Initiates the training process for BeatNet using a specified configuration file. Ensure the configuration file path is correct.

```python
python -m BeatNet.train --config src/BeatNet/configs/default.yaml
```

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

### Install BeatNet for Training (Source)

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Install BeatNet in editable mode from the source code, typically used for training or development.

```bash
pip install -e .
```

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

### Install BeatNet from Git Repository

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Install BeatNet directly from its GitHub repository for the latest development version.

```bash
pip install git+https://github.com/mjhydri/BeatNet
```

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

### Install BeatNet from PyPI

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Use this command to install the BeatNet package directly from the Python Package Index.

```bash
pip install BeatNet
```

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

### Monitor BeatNet Training with TensorBoard

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Launches TensorBoard to visualize training logs. Point TensorBoard to the directory containing the training logs, typically 'output/tensorboard'.

```bash
tensorboard --logdir output/tensorboard
```

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

### Initialize BeatNet in Online Mode

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Initialize the BeatNet estimator for online audio processing from a file. Plots activations for visualization.

```python
from BeatNet.BeatNet import BeatNet

estimator = BeatNet(1, mode='online', inference_model='PF', plot=['activations'], thread=False)

Output = estimator.process("audio file directory")
```

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

### Initialize BeatNet for Streaming Mode

Source: https://context7.com/mjhydri/beatnet/llms.txt

Sets up BeatNet for real-time audio processing directly from the microphone. This mode requires the Particle Filtering inference model and outputs beat detections as they occur. Ensure microphone input is loud for optimal results.

```python
from BeatNet.BeatNet import BeatNet

# Initialize for streaming from microphone
estimator = BeatNet(
    model=1,
    mode='stream',
    inference_model='PF',  # Must use PF for streaming
    plot=['beat_particles'],  # Optional: visualize particle states
    thread=False
)

# Start continuous processing (blocks until stream is stopped)
# Prints "beat!" or "*beat!" (downbeat) to console as beats are detected
output = estimator.process()
```

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

### Initialize BeatNet in Realtime Mode

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Initialize the BeatNet estimator for realtime audio processing from a file. Plots beat particles for visualization.

```python
from BeatNet.BeatNet import BeatNet

estimator = BeatNet(1, mode='realtime', inference_model='PF', plot=['beat_particles'], thread=False)

Output = estimator.process("audio file directory")
```

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

### Build and Use BeatNetDataset for PyTorch

Source: https://context7.com/mjhydri/beatnet/llms.txt

Demonstrates how to build training, validation, and test datasets using `build_datasets` from a configuration file. The `BeatNetDataset` provides a PyTorch Dataset interface, supporting random cropping for training and full-track loading for validation/testing.

```python
from BeatNet.dataset import BeatNetDataset, build_datasets
import yaml

# Load training configuration
with open('src/BeatNet/configs/default.yaml', 'r') as f:
    config = yaml.safe_load(f)

# Build train/val/test datasets from prepared data
train_dataset, val_dataset, test_dataset = build_datasets(config)

print(f"Training samples: {len(train_dataset)}")
print(f"Validation samples: {len(val_dataset)}")
print(f"Test samples: {len(test_dataset)}")

# Access a training sample
sample = train_dataset[0]
print(f"Features shape: {sample['feats'].shape}")       # (272, seq_len)
print(f"Ground truth shape: {sample['ground_truth'].shape}")  # (3, seq_len)
# Ground truth rows: [beat, downbeat, non-beat] one-hot encoding
```

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

### Initialize BeatNet for Online Processing with Numpy Array

Source: https://context7.com/mjhydri/beatnet/llms.txt

Initializes BeatNet for online processing and demonstrates how to process audio directly from a NumPy array. Ensure the audio data has a sample rate of 22050 Hz.

```python
from BeatNet.BeatNet import BeatNet
import numpy as np

# Initialize for online processing with particle filtering
estimator = BeatNet(
    model=1,
    mode='online',
    inference_model='PF',
    plot=[],
    thread=False
)

# Process from file path
output = estimator.process("audio.wav")

# Or process from numpy array (must be 22050 Hz sample rate)
import librosa
audio, sr = librosa.load("audio.wav", sr=22050)
output = estimator.process(audio)
```

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

### Resume BeatNet Training from Checkpoint

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Resumes a previously interrupted training session from a saved checkpoint file. Specify the path to the checkpoint.

```python
python -m BeatNet.train --config src/BeatNet/configs/default.yaml \
    --resume output/checkpoint_epoch_100.pt
```

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

### Initialize BeatNet in Streaming Mode

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Initialize the BeatNet estimator for streaming audio input. Ensure the input is loud for optimal performance.

```python
from BeatNet.BeatNet import BeatNet

estimator = BeatNet(1, mode='stream', inference_model='PF', plot=[], thread=False)

Output = estimator.process()
```

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

### Create DataLoader for Training

Source: https://context7.com/mjhydri/beatnet/llms.txt

This snippet demonstrates how to create a PyTorch DataLoader for training a BeatNet model. It configures batch size, shuffling, and number of workers. The loop shows how to access features, ground truth, and times from a batch.

```python
from torch.utils.data import DataLoader

train_loader = DataLoader(
    train_dataset,
    batch_size=200,
    shuffle=True,
    num_workers=4,
    drop_last=True
)

for batch in train_loader:
    feats = batch['feats']           # (batch, 272, seq_len)
    gt = batch['ground_truth']       # (batch, 3, seq_len)
    times = batch['times']           # (batch, seq_len)
    break
```

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

### Configure BeatNet Training via CLI

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Overrides default configuration options directly from the command line during training. Useful for quick adjustments to parameters like learning rate and batch size.

```python
python -m BeatNet.train --config src/BeatNet/configs/default.yaml \
    learning_rate=0.001 batch_size=128 device=cuda
```

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

### Initialize BeatNet in Offline Mode

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Initialize the BeatNet estimator for offline audio processing from a file using the DBN inference model.

```python
from BeatNet.BeatNet import BeatNet

estimator = BeatNet(1, mode='offline', inference_model='DBN', plot=[], thread=False)

Output = estimator.process("audio file directory")
```

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

### Train BeatNet Model via CLI

Source: https://context7.com/mjhydri/beatnet/llms.txt

Command-line execution for training the BeatNet CRNN model. Supports configuration via YAML files and allows overriding parameters like learning rate, batch size, and device.

```bash
# Command-line training
# python -m BeatNet.train --config src/BeatNet/configs/default.yaml
```

```bash
# With CLI overrides
# python -m BeatNet.train --config src/BeatNet/configs/default.yaml \
#     learning_rate=0.001 batch_size=128 device=cuda
```

```bash
# Resume from checkpoint
# python -m BeatNet.train --config src/BeatNet/configs/default.yaml \
#     --resume output/checkpoint_epoch_100.pt
```

```bash
# Monitor with TensorBoard
# tensorboard --logdir output/tensorboard
```

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

### Initialize BeatNet for Realtime File Processing

Source: https://context7.com/mjhydri/beatnet/llms.txt

Configures BeatNet to process audio files chunk by chunk, simulating real-time output. This mode uses Particle Filtering and visualizes neural network activations. Access detected beat and downbeat times from the output array.

```python
from BeatNet.BeatNet import BeatNet

# Initialize for realtime file processing
estimator = BeatNet(
    model=2,           # Use Ballroom-trained model
    mode='realtime',
    inference_model='PF',
    plot=['activations', 'beat_particles'],  # Visualize neural network activations
    thread=False
)

# Process audio file with real-time visualization
output = estimator.process("/path/to/song.mp3")

# Access beat and downbeat times
beat_times = output[:, 0]  # All beat timestamps
downbeat_mask = output[:, 1] == 1
downbeat_times = output[downbeat_mask, 0]

print(f"Detected {len(beat_times)} beats, {len(downbeat_times)} downbeats")
```

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

### Prepare Data for Training

Source: https://context7.com/mjhydri/beatnet/llms.txt

Command-line usage for the `prepare_data` module, which extracts LOG_SPECT features and beat/downbeat annotations. Requires specifying a configuration file, raw data directory, and dataset names.

```bash
# Command-line usage for data preparation
# python -m BeatNet.prepare_data --config src/BeatNet/configs/default.yaml \
#     --raw_dir /path/to/raw_datasets \
#     --dataset BALLROOM GTZAN
```

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

### Initialize BeatNet for Online Processing

Source: https://context7.com/mjhydri/beatnet/llms.txt

Initializes the BeatNet class for online processing using a specified pre-trained model, inference method, and device. The output is a numpy array containing beat and downbeat timestamps.

```python
from BeatNet.BeatNet import BeatNet

# Initialize with model 1 (GTZAN-trained), online mode, particle filtering inference
estimator = BeatNet(
    model=1,           # Pre-trained model: 1=GTZAN, 2=Ballroom, 3=Rock Corpus
    mode='online',     # Processing mode: 'stream', 'realtime', 'online', 'offline'
    inference_model='PF',  # Inference: 'PF' (Particle Filter) or 'DBN' (Dynamic Bayesian Network)
    plot=[],           # Visualization: 'activations', 'beat_particles', 'downbeat_particles'
    thread=False,      # Run inference in separate thread
    device='cpu'       # Device: 'cpu' or 'cuda'
)

# Process an audio file
output = estimator.process("path/to/audio.wav")

# Output format: numpy array (num_beats, 2)
# Column 0: beat time in seconds
# Column 1: beat type (1 = downbeat, 2 = regular beat)
print(output)
# Example output:
# [[0.52  1.  ]    # Downbeat at 0.52 seconds
#  [1.04  2.  ]    # Beat at 1.04 seconds
#  [1.56  2.  ]    # Beat at 1.56 seconds
#  [2.08  1.  ]    # Downbeat at 2.08 seconds
#  ...]
```

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

### Prepare Data Script

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Execute the data preparation script to extract features and annotations for training. Ensure the raw dataset directory and configuration file path are correctly specified.

```bash
python -m BeatNet.prepare_data --config src/BeatNet/configs/default.yaml     --raw_dir /path/to/raw_datasets     --dataset BALLROOM GTZAN BEATLES CMR ROCK_CORPUS
```

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

### Initialize and Use LOG_SPECT Feature Extractor

Source: https://context7.com/mjhydri/beatnet/llms.txt

Initializes the `LOG_SPECT` class to extract log-filtered magnitude spectrograms and their differences. This produces 272-dimensional feature vectors per frame at 50 fps, suitable for the BDA model. Ensure the audio is loaded at the specified sample rate.

```python
from BeatNet.log_spect import LOG_SPECT
import librosa
import numpy as np

# Initialize feature extractor
feature_extractor = LOG_SPECT(
    num_channels=1,
    sample_rate=22050,
    win_length=1411,    # 64ms window
    hop_size=441,       # 20ms hop (50 fps)
    n_bands=[24],       # Number of mel bands
    mode='online'       # 'online'/'offline' for full files, 'realtime'/'stream' for chunks
)

# Load audio at 22050 Hz
audio, sr = librosa.load("song.wav", sr=22050)

# Extract features
features = feature_extractor.process_audio(audio)
print(f"Feature shape: {features.shape}")  # (272, num_frames)

# Features can be fed directly to the BDA model
# After transposing to (num_frames, 272) for batch processing
```

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

### Initialize BeatNet for Offline Processing

Source: https://context7.com/mjhydri/beatnet/llms.txt

Initializes the BeatNet estimator for offline, non-causal batch processing using a Dynamic Bayesian Network (DBN) for maximum accuracy. Ensure the 'DBN' inference model is specified for offline mode.

```python
from BeatNet.BeatNet import BeatNet

# Initialize for offline processing with DBN inference
estimator = BeatNet(
    model=3,           # Use Rock Corpus-trained model
    mode='offline',
    inference_model='DBN',  # Must use DBN for offline mode
    plot=[],
    thread=False
)
```

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

### Initialize and Run Particle Filter Cascade

Source: https://context7.com/mjhydri/beatnet/llms.txt

Initializes the `particle_filter_cascade` for causal beat and downbeat tracking. It processes activation probabilities from a neural network to detect beat times and types. Set `beats_per_bar` to an empty list to auto-detect meter.

```python
from BeatNet.particle_filtering_cascade import particle_filter_cascade
import numpy as np

# Initialize particle filter
pf = particle_filter_cascade(
    beats_per_bar=[],       # Empty = auto-detect meter (2-4 beats per bar)
    fps=50,                 # Frames per second (matches feature extraction)
    plot=[],                # Visualization options
    mode='online',          # Processing mode
    min_bpm=55,             # Minimum tempo
    max_bpm=215,            # Maximum tempo
    particle_size=1500,     # Number of beat particles
    down_particle_size=250  # Number of downbeat particles
)

# Process activation probabilities (from neural network output)
# Shape: (num_frames, 2) where columns are [beat_prob, downbeat_prob]
activations = np.random.rand(500, 2)  # Example activations
activations[:, 0] = np.clip(activations[:, 0], 0.1, 0.9)
activations[:, 1] = np.clip(activations[:, 1], 0.05, 0.8)

# Run inference
output = pf.process(activations)

# Output format: (num_beats, 2)
# Column 0: beat time in seconds
# Column 1: beat type (1 = downbeat, 2 = beat)
if output is not None and len(output) > 0:
    print(f"Detected {len(output)} beats")
    print(f"First beat at {output[0, 0]:.3f}s, type: {'downbeat' if output[0, 1] == 1 else 'beat'}")
```

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

### Run Training Pipeline Test Suite

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Execute the Python test script to validate the entire training pipeline with synthetic data. This covers data preparation, model training, and validation.

```bash
python test/test_training.py
```

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

### Madmom Compatibility Fix

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Apply these Python code fixes to `sitecustomize.py` to resolve compatibility issues with madmom, Python 3.10+, and NumPy 1.24+.

```python
import numpy as np
if not hasattr(np, 'float'): np.float = np.float64
if not hasattr(np, 'int'): np.int = np.int_
```

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

### Load Trained Weights for Inference

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

Use this Python snippet to load pre-trained model weights for online inference. Ensure the 'output/best_model_weights.pt' path is correct.

```python
from BeatNet.BeatNet import BeatNet
import torch

estimator = BeatNet(1, mode='online', inference_model='PF', plot=[])
estimator.model.load_state_dict(
    torch.load('output/best_model_weights.pt', map_location='cpu'), strict=False
)
output = estimator.process("audio_file.wav")
```

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

### Initialize and Use BDA Neural Network

Source: https://context7.com/mjhydri/beatnet/llms.txt

Initializes the BDA CRNN model for beat and downbeat activation. Use `train_forward` for stateless training and `forward` for stateful inference in streaming scenarios. Ensure input features match the expected dimension.

```python
from BeatNet.model import BDA
import torch

# Initialize the neural network
model = BDA(
    dim_in=272,      # Input feature dimension (136 spectrogram + 136 difference)
    num_cells=150,   # LSTM hidden size
    num_layers=2,    # Number of LSTM layers
    device='cpu'     # Device (cpu or cuda)
)

# Create sample input: batch of 4 sequences, 100 frames each, 272 features
sample_input = torch.randn(4, 100, 272)

# Forward pass for training (stateless LSTM)
output = model.train_forward(sample_input)
print(f"Output shape: {output.shape}")  # (4, 3, 100) - [batch, classes, frames]

# Apply softmax for probability output
probs = model.final_pred(output[0])  # (3, 100) - probabilities per frame
# Row 0: beat probability
# Row 1: downbeat probability
# Row 2: non-beat probability

# For inference with state (streaming), use forward()
model.eval()
with torch.no_grad():
    single_frame = torch.randn(1, 1, 272)
    output = model(single_frame)
    probs = model.final_pred(output[0])
```

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

### Calculate Tempo from Beat Intervals

Source: https://context7.com/mjhydri/beatnet/llms.txt

Calculates the average tempo in BPM from an array of beat interval timestamps. Requires at least two beat timestamps to compute.

```python
if len(output) > 1:
    beat_intervals = np.diff(output[:, 0])
    avg_tempo = 60.0 / np.mean(beat_intervals)
    print(f"Estimated tempo: {avg_tempo:.1f} BPM")
```

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

### Load Custom Trained Weights

Source: https://context7.com/mjhydri/beatnet/llms.txt

Loads custom trained model weights into a BeatNet inference instance. The `strict=False` argument allows loading weights even if hidden state tensors are not present in the saved file.

```python
from BeatNet.BeatNet import BeatNet
import torch

# Initialize BeatNet with any pre-trained model (will be overwritten)
estimator = BeatNet(
    model=1,
    mode='online',
    inference_model='PF',
    plot=[]
)

# Load custom trained weights
estimator.model.load_state_dict(
    torch.load('output/best_model_weights.pt', map_location='cpu'),
    strict=False  # Allows loading weights without hidden state tensors
)

# Process audio with custom model
output = estimator.process("test_audio.wav")
print(f"Detected {len(output)} beats using custom model")
```

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

### BeatNet Citation (ISMIR)

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

BibTeX entry for citing the BeatNet paper at ISMIR 2021.

```bibtex
@inproceedings{heydari2021beatnet,
  title={BeatNet: CRNN and Particle Filtering for Online Joint Beat Downbeat and Meter Tracking},
  author={Heydari, Mojtaba and Cwitkowitz, Frank and Duan, Zhiyao},
  journal={22th International Society for Music Information Retrieval Conference, ISMIR},
  year={2021}
}
```

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

### BeatNet Citation (ICASSP)

Source: https://github.com/mjhydri/beatnet/blob/main/README.md

BibTeX entry for citing the related paper on online beat tracking at ICASSP 2021.

```bibtex
@inproceedings{heydari2021don,
  title={Don’t look back: An online beat tracking method using RNN and enhanced particle filtering},
  author={Heydari, Mojtaba and Duan, Zhiyao},
  booktitle={ICASSP 2021-2021 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)},
  pages={236--240},
  year={2021},
  organization={IEEE}
}
```

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

### Process Audio and Extract Downbeats

Source: https://context7.com/mjhydri/beatnet/llms.txt

Processes an audio file using the initialized BeatNet estimator and extracts downbeat timestamps. Downbeats are identified where the beat number in the output is 1.

```python
# Process audio file
output = estimator.process("rock_song.mp3")

# Extract downbeats (beat number == 1)
downbeats = output[output[:, 1] == 1]
print(f"Downbeat times: {downbeats[:, 0]}")
```

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

### Estimate Time Signature from Beat Groupings

Source: https://context7.com/mjhydri/beatnet/llms.txt

Calculates the estimated time signature by analyzing the number of beats between consecutive downbeats. This assumes a consistent meter within the analyzed segment.

```python
# Calculate time signature from beat groupings
beats_per_bar = []
current_bar_beats = 0
for i, row in enumerate(output):
    if row[1] == 1 and current_bar_beats > 0:
        beats_per_bar.append(current_bar_beats)
        current_bar_beats = 1
    else:
        current_bar_beats += 1

if beats_per_bar:
    estimated_meter = round(np.mean(beats_per_bar))
    print(f"Estimated time signature: {estimated_meter}/4")
```

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