ChatTTS: 39.3K+ Stars — So Sánh Benchmark TTS Hội Thoại vs Coqui, MeloTTS 2026

import ChatTTS
import torch

chat = ChatTTS.Chat()
chat.load(compile=False)

# Lấy mẫu và lưu nhúng ngườ nói
rand_spk = chat.sample_random_speaker()
print(f"Kích thước nhúng ngườ nói: {rand_spk.shape}")

# Lưu để sử dụng sau
torch.save(rand_spk, "speaker_embedding.pt")

# Tạo môi trường ảo
conda create -n chattts python=3.11
conda activate chattts

# Cài đặt ChatTTS
pip install ChatTTS

# Cài đặt tùy chọn cho tăng tốc GPU
pip install torchaudio

git clone https://github.com/2noise/ChatTTS
cd ChatTTS
pip install -e .

# Clone repository
git clone https://github.com/2noise/ChatTTS
cd ChatTTS

# Build và chạy bằng Docker
docker build -t chattts .
docker run --gpus all -p 8080:8080 chattts

import ChatTTS
print(f"Phiên bản ChatTTS: {ChatTTS.__version__}")

# Kiểm tra suy luận nhanh
chat = ChatTTS.Chat()
chat.load(compile=False)
texts = ["Xin chào, đây là bản kiểm tra ChatTTS."]
wavs = chat.infer(texts)
print(f"Kích thước âm thanh: {wavs[0].shape}")

python examples/web/webui.py

python examples/cmd/run.py "Đoạn văn bản đầu tiên của bạn." "Đoạn văn bản thứ hai của bạn."

# openai_api_server.py — Endpoint ChatTTS tương thích OpenAI
import ChatTTS
import torch
import torchaudio
from fastapi import FastAPI
from pydantic import BaseModel
import io
import base64

app = FastAPI()
chat = ChatTTS.Chat()
chat.load(compile=True)  # Bật torch.compile cho production

class TTSRequest(BaseModel):
    model: str = "chattts"
    input: str
    voice: str = "default"
    response_format: str = "mp3"

@app.post("/v1/audio/speech")
async def create_speech(request: TTSRequest):
    params_infer_code = ChatTTS.Chat.InferCodeParams(
        temperature=0.3,
        top_P=0.7,
        top_K=20,
    )
    wavs = chat.infer([request.input], params_infer_code=params_infer_code)
    buffer = io.BytesIO()
    torchaudio.save(buffer, torch.from_numpy(wavs[0]).unsqueeze(0), 24000, format="mp3")
    buffer.seek(0)
    return {"audio": base64.b64encode(buffer.read()).decode()}

uvicorn openai_api_server:app --host 0.0.0.0 --port 8000 --workers 2

# Tích hợp ChatTTS vào pipeline agent LangChain
from langchain.agents import Tool, AgentExecutor, create_react_agent
from langchain_openai import ChatOpenAI
import ChatTTS
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

def tts_tool(text: str) -> str:
    """Tạo giọng nói và trả về đường dẫn tệp."""
    wavs = chat.infer([text])
    filepath = "/tmp/response.wav"
    torchaudio.save(filepath, torch.from_numpy(wavs[0]).unsqueeze(0), 24000)
    return filepath

tools = [
    Tool(
        name="text_to_speech",
        func=tts_tool,
        description="Chuyển đổi phản hồi văn bản thành âm thanh"
    )
]

llm = ChatOpenAI(model="gpt-4o")
agent = create_react_agent(llm, tools, prompt="Bạn là trợ lý giọng nói.")

# Giao diện Gradio tùy chỉnh cho triển khai production
import gradio as gr
import ChatTTS
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

def generate_speech(text, temperature, top_p, top_k, oral_level, laugh_level, break_level):
    params_refine_text = ChatTTS.Chat.RefineTextParams(
        prompt=f"[oral_{oral_level}][laugh_{laugh_level}][break_{break_level}]"
    )
    params_infer_code = ChatTTS.Chat.InferCodeParams(
        temperature=temperature,
        top_P=top_p,
        top_K=top_k,
    )
    wavs = chat.infer([text], params_refine_text=params_refine_text, params_infer_code=params_infer_code)
    filepath = "/tmp/output.wav"
    torchaudio.save(filepath, torch.from_numpy(wavs[0]).unsqueeze(0), 24000)
    return filepath

demo = gr.Interface(
    fn=generate_speech,
    inputs=[
        gr.Textbox(label="Văn bản", value="Xin chào! Hôm nay bạn thế nào?"),
        gr.Slider(0.1, 1.0, 0.3, label="Temperature"),
        gr.Slider(0.1, 1.0, 0.7, label="Top P"),
        gr.Slider(1, 50, 20, label="Top K"),
        gr.Slider(0, 9, 2, label="Mức ngữ điệu"),
        gr.Slider(0, 2, 0, label="Mức cườ"),
        gr.Slider(0, 7, 6, label="Mức nghỉ"),
    ],
    outputs=gr.Audio(label="Giọng nói đã tạo"),
    title="ChatTTS Production UI"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

# Tạo âm thanh streaming cho hội thoại thờ gian thực
import ChatTTS
import numpy as np
import sounddevice as sd

chat = ChatTTS.Chat()
chat.load(compile=True)

class StreamingTTS:
    def __init__(self, chat_model):
        self.chat = chat_model
        self.sample_rate = 24000

    def stream_and_play(self, text: str):
        """Tạo âm thanh và phát theo khúc."""
        wavs = self.chat.infer([text])
        audio = wavs[0]
        sd.play(audio, self.sample_rate)
        sd.wait()

streamer = StreamingTTS(chat)
streamer.stream_and_play("Để tôi suy nghĩ một chút...")

# Thêm metrics Prometheus cho API ChatTTS
from prometheus_client import Counter, Histogram, generate_latest
from fastapi import Response

TTS_REQUESTS = Counter("chattts_requests_total", "Tổng yêu cầu TTS", ["status"])
TTS_LATENCY = Histogram("chattts_inference_seconds", "Độ trễ suy luận")

@app.post("/v1/audio/speech")
async def create_speech(request: TTSRequest):
    with TTS_LATENCY.time():
        try:
            wavs = chat.infer([request.input])
            TTS_REQUESTS.labels(status="success").inc()
        except Exception as e:
            TTS_REQUESTS.labels(status="error").inc()
            raise

@app.get("/metrics")
async def metrics():
    return Response(generate_latest(), media_type="text/plain")

import ChatTTS
import torchaudio
import time

chat = ChatTTS.Chat()
chat.load(compile=True)

class VoiceAssistant:
    def synthesize_response(self, text: str) -> str:
        start = time.time()
        params = ChatTTS.Chat.InferCodeParams(temperature=0.3, top_P=0.7)
        wavs = chat.infer([text], params_infer_code=params)
        filepath = "/tmp/response.wav"
        torchaudio.save(filepath, torch.from_numpy(wavs[0]).unsqueeze(0), 24000)
        elapsed = time.time() - start
        print(f"Độ trễ TTS: {elapsed:.2f} giây")
        return filepath

assistant = VoiceAssistant()
audio_path = assistant.synthesize_response(
    "Đây là câu hỏi thú vị! Để tôi nghĩ... [uv_break] "
    "Được, câu trả lờ phụ thuộc vào thiết lập của bạn."
)

import ChatTTS
import torchaudio

chat = ChatTTS.Chat()
chat.load(compile=False)

# Lấy mẫu hai ngườ nói khác nhau
speaker_a = chat.sample_random_speaker()  # Giọng nữ
speaker_b = chat.sample_random_speaker()  # Giọng nam

dialogue = [
    ("Này, tối qua có xem trận đấu không?", speaker_a),
    ("Có! Bàn thắng cuối tuyệt vờ!", speaker_b),
    ("Đúng không! [laugh] Tôi không thể tin được.", speaker_a),
]

for i, (text, spk) in enumerate(dialogue):
    params = ChatTTS.Chat.InferCodeParams(spk_emb=spk, temperature=0.3)
    wavs = chat.infer([text], params_infer_code=params)
    torchaudio.save(f"dialogue_{i}.wav", torch.from_numpy(wavs[0]).unsqueeze(0), 24000)

import ChatTTS
chat = ChatTTS.Chat()
chat.load(compile=True)

import ChatTTS
import torch

chat = ChatTTS.Chat()
chat.load(compile=False)

# Tạo và lưu nhúng ngườ nói
speakers = {}
for name in ["agent", "user", "narrator"]:
    spk = chat.sample_random_speaker()
    speakers[name] = spk
    torch.save(spk, f"speakers/{name}.pt")

# Tải ngườ nói hiện có
spk_agent = torch.load("speakers/agent.pt")
params = ChatTTS.Chat.InferCodeParams(spk_emb=spk_agent)

import torch
from ChatTTS import Chat

chat = Chat()
chat.load(compile=False)

@torch.inference_mode()
def infer_with_cleanup(texts, params):
    with torch.cuda.amp.autocast():
        wavs = chat.infer(texts, params_infer_code=params)
    torch.cuda.empty_cache()
    return wavs

# health_check.py — Probe sức khỏe cho Kubernetes
from fastapi import FastAPI, HTTPException
import ChatTTS

app = FastAPI()
chat = ChatTTS.Chat()

try:
    chat.load(compile=False)
    MODEL_LOADED = True
except Exception as e:
    MODEL_LOADED = False
    print(f"Tải mô hình thất bại: {e}")

@app.get("/health")
def health():
    if not MODEL_LOADED:
        raise HTTPException(status_code=503, detail="Mô hình chưa được tải")
    return {"status": "healthy", "model": "chattts", "version": "0.2.5"}

@app.get("/ready")
def ready():
    return {"status": "ready"}

# chattts-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: chattts-api
spec:
  replicas: 2
  selector:
    matchLabels:
      app: chattts
  template:
    metadata:
      labels:
        app: chattts
    spec:
      containers:
      - name: chattts
        image: chattts:0.2.5
        resources:
          limits:
            nvidia.com/gpu: 1
            memory: "8Gi"
          requests:
            memory: "4Gi"
        ports:
        - containerPort: 8000
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          periodSeconds: 30
        readinessProbe:
          httpGet:
            path: /ready
            port: 8000
          periodSeconds: 10