GPA: One Model for Speech Recognition, Text-to-Speech, and Voice Conversion

TL;DR GPA incorporates three speech tasks into one single model and this repo includes codes of training, fine-tuning and effecient deployment of GPA.

GPA stands for General Purpose Audio.

In academia, a student’s GPA (Grade Point Average) serves as a unified metric that reflects performance across diverse subjects—ranging from Calculus and Philosophy to Gym class.

Similarly, our GPA model unifies the three major pillars of audio tasks—Text-to-Speech (TTS), Automatic Speech Recognition (ASR), and Voice Conversion (VC)—into a single auto-regreesive transformer.

• Our open-source content includes support for multiple frameworks and provides production-ready code suitable for cloud deployment.
• we include concise inference examples and training pipelines for research purpose.
• The released 0.3B model is also perfect for edge devices and edge deployment is to be released.

Figure 1: Architecture of the proposed GPA framework. The model utilizes a shared Large Language Model (LLM) backbone to unify three core audio tasks: Understanding (ASR), Generation (TTS), and Editing (Voice Conversion). Depending on the task, the model processes different combinations of inputs (Source Audio, Target Text, or Reference Audio) via Semantic and Acoustic modules to generate the corresponding text or audio output.

⚠️ Prerequisites (Important)

The default development environment is configured for:

• • OS: Linux (x86_64)*
• • GPU: NVIDIA*
• • CUDA: 12.x*

The provided uv.lock file was generated under this configuration.

If your system matches the above, you can use the uv-based setup for a fully reproducible environment.

If you are using:

• CUDA 11.x (e.g. cu116)
• CPU-only systems
• macOS or Windows

please follow the pip-based installation described below.

We use uv for fast and reproducible Python environment management.

1. Install uv

curl -LsSf https://astral.sh/uv/install.sh | sh

# Or install via pip if you prefer:
# pip install uv

2. Sync the environment (installs all dependencies)

💡Note: If training is not required, or if building flash_attn is difficult/slow on your device, you may comment out this dependency in pyproject.toml. Training should be switched to eager mode in such condition.

uv sync

1. Create and activate a virtual environment

python -m venv .venv
source .venv/bin/activate

2. Install base dependencies

pip install -r requirements.txt

Before running inference, please download the model checkpoints from Hugging Face or ModelScope.

Important: After downloading the checkpoints, please verify that your model directory structure matches the hierarchy below.

${GPA_MODEL_DIR}/
├── BiCodec/
├──── wav2vec2-large-xlsr-53/
├── glm-4-voice-tokenizer/
├── added_tokens.json
├── chat_template.jinja
├── config.json
├── generation_config.json
├── merges.txt
├── model.safetensors
├── special_tokens_map.json
├── tokenizer_config.json
├── tokenizer.json
└── vocab.json

You can perform various tasks like Speech-to-Text, Text-to-Speech, and Voice Conversion using the provided scripts.

💡Note: Please navigate to the inference directory to ensure relative paths for audio files work correctly.

💡Note: Currently, we only support input in WAV format at a sample rate of 16 kHz.

cd scripts/inference

💡Note: To use other python environments, replace "uv run" with "path_to_your_python".

Speech-to-Text (STT/ASR):

# Using uv
uv run gpa_inference.py --task stt \
    --src_audio_path "test_audio/000.wav" \
    --gpa_model_path "${GPA_MODEL_DIR}" \
    --tokenizer_path "${GPA_MODEL_DIR}/glm-4-voice-tokenizer" \
    --bicodec_tokenizer_path "${GPA_MODEL_DIR}/BiCodec" \
    --text_tokenizer_path "${GPA_MODEL_DIR}"

# Or using python
python gpa_inference.py --task stt \
    --src_audio_path "test_audio/000.wav" \
    --gpa_model_path "${GPA_MODEL_DIR}" \
    --tokenizer_path "${GPA_MODEL_DIR}/glm-4-voice-tokenizer" \
    --bicodec_tokenizer_path "${GPA_MODEL_DIR}/BiCodec" \
    --text_tokenizer_path "${GPA_MODEL_DIR}"

Text-to-Speech (TTS):

# Using uv
uv run gpa_inference.py --task tts-a \
    --text "Hello world, this is Major Tom speaking." \
    --ref_audio_path "test_audio/astro.wav" \
    --gpa_model_path "${GPA_MODEL_DIR}" \
    --tokenizer_path "${GPA_MODEL_DIR}/glm-4-voice-tokenizer" \
    --bicodec_tokenizer_path "${GPA_MODEL_DIR}/BiCodec" \
    --text_tokenizer_path "${GPA_MODEL_DIR}"

# Or using python
python gpa_inference.py --task tts-a \
    --text "Hello world, this is Major Tom speaking." \
    --ref_audio_path "test_audio/astro.wav" \
    --gpa_model_path "${GPA_MODEL_DIR}" \
    --tokenizer_path "${GPA_MODEL_DIR}/glm-4-voice-tokenizer" \
    --bicodec_tokenizer_path "${GPA_MODEL_DIR}/BiCodec" \
    --text_tokenizer_path "${GPA_MODEL_DIR}"

Voice Conversion (VC):

# Using uv
uv run gpa_inference.py --task vc \
    --src_audio_path "test_audio/vc_src.wav" \
    --ref_audio_path "test_audio/astro.wav" \
    --gpa_model_path "${GPA_MODEL_DIR}" \
    --tokenizer_path "${GPA_MODEL_DIR}/glm-4-voice-tokenizer" \
    --bicodec_tokenizer_path "${GPA_MODEL_DIR}/BiCodec" \
    --text_tokenizer_path "${GPA_MODEL_DIR}"

# Or using python
python gpa_inference.py --task vc \
    --src_audio_path "test_audio/vc_src.wav" \
    --ref_audio_path "test_audio/astro.wav" \
    --gpa_model_path "${GPA_MODEL_DIR}" \
    --tokenizer_path "${GPA_MODEL_DIR}/glm-4-voice-tokenizer" \
    --bicodec_tokenizer_path "${GPA_MODEL_DIR}/BiCodec" \
    --text_tokenizer_path "${GPA_MODEL_DIR}"

For more details on inference arguments, check out the Inference README.

We provide a training script to help you get started. A small sample dataset is included in the repository to quickly verify that the pipeline works as expected:

• scripts/train/merged_shuffled_train.jsonl
• scripts/train/dataset

💡Note: Before running, be sure to update the paths in train_gpa.sh.

# Run the training script (uses DeepSpeed)
cd scripts/train
bash train_gpa.sh

The training script automatically handles environment activation via uv run.

Building your own dataset is as simple as following the format of our provided .jsonl example (scripts/train/merged_shuffled_train.jsonl) and pointing it to your prepared data.

We provide a complete set of scripts for service deployment, including a FastAPI-based backend server, a Gradio-based GUI, and basic testing scripts.

⚠️ Caution: The current vLLM-based deployment may exhibit occasional audio quality degradation under large-scale concurrent workloads. For reliable evaluation and quality validation, we recommend using the basic PyTorch inference implementation provided in the inference module.

The core service is built with FastAPI. We utilize a Dockerfile to build the runtime environment, ensuring consistency and ease of deployment.

1. Ensure you have Docker and Docker Compose installed.

2. Set the required environment variables (e.g., in a .env file or export them).

   Please configure GPA_CODE_ROOT and GPA_MODEL_DIR. For model preparation, refer to Checkpoint Download.

   export GPA_CODE_ROOT="/absolute/path/to/this/repo"
   export GPA_MODEL_DIR="/absolute/path/to/models"

3. Run with Docker Compose:

   cd scripts/server
   docker compose up -d --build

4. Test: You can use the provided client script to verify that the service is working correctly.

   # Run the test client
   python test_client.py

We provide a user-friendly web interface for interacting with the API.

💡Note: The GUI uses the original PyTorch deployment instead of vLLM

# Install Gradio if not already installed
pip install gradio

# Start the GUI app
cd scripts/server
python gui_app.py

The GUI will be available at http://localhost:7868.

The following results are obtained by benchmarking services instantiated via the official deployment scripts, reflecting end-to-end performance in realistic serving scenarios rather than offline inference.

Among currently available open-source systems, our model is one of the few that natively supports both concurrent and streaming inference, while achieving performance comparable to the first tier of existing approaches.

💡Note

• TTFC: Time To First Chunk (TTS)
• TTFT: Time To First Token (ASR)
• RTF: Real-Time Factor (audio duration / synthesis time)

Note: ASR results on Librispeech and Aishell-1. WER (%) is reported for Librispeech, and CER (%) is reported for Aishell-1.

We borrowed a lot of code from the following excellent projects:

• Spark-TTS
• GLM-4-Voice
• Emilia
• FlashTTS
• Qwen

If you find GPA useful for your research or projects, please cite us:

@misc{gpa2026,
  title={Unifying Speech Recognition, Synthesis and Conversion with Autoregressive Transformer},
  author={Runyuan Cai, Yu Lin, Yiming Wang, Chunlin Fu and Xiaodong Zeng},
  year={2026},
  howpublished={\url{https://github.com/AutoArk/GPA}},
}