Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,43 @@
+FROM python:3.11-slim-bookworm
+
+ENV DEBIAN_FRONTEND=noninteractive \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    HF_HOME=/opt/models \
+    TRANSFORMERS_CACHE=/opt/models \
+    HUGGINGFACE_HUB_CACHE=/opt/models
+
+WORKDIR /code
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        git \
+        wget \
+        curl \
+        libsndfile1 \
+        ffmpeg \
+        gcc \
+        g++ \
+        build-essential \
+        python3-dev \
+    && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Pre-download model
+RUN python - <<EOF
+from huggingface_hub import snapshot_download
+snapshot_download(
+    repo_id="LiquidAI/LFM2.5-Audio-1.5B",
+    local_dir="/opt/models/LiquidAI/LFM2.5-Audio-1.5B",
+    local_dir_use_symlinks=False
+)
+print("Model downloaded successfully.")
+EOF
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app/main.py

@@ -0,0 +1,179 @@
+
+
+import asyncio
+import json
+import torch
+import numpy as np
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from pydantic import BaseModel
+from liquid_audio import (
+    LFM2AudioModel,
+    LFM2AudioProcessor,
+    ChatState,
+)
+
+
+HF_REPO = "LiquidAI/LFM2.5-Audio-1.5B"
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+SAMPLE_RATE = 24_000
+CHUNK_SIZE = 6
+
+if DEVICE == "cuda" and torch.cuda.is_bf16_supported():
+    DTYPE = torch.bfloat16
+else:
+    DTYPE = torch.float32
+
+torch.backends.cuda.matmul.allow_tf32 = True
+
+
+
+
+
+processor = LFM2AudioProcessor.from_pretrained(HF_REPO)
+model = LFM2AudioModel.from_pretrained(
+    HF_REPO,
+    torch_dtype=DTYPE,
+).to(DEVICE).eval()
+
+print(f"[BOOT]  LFM2.5 Loaded on {DEVICE}")
+
+
+
+
+
+app = FastAPI(title="LFM2.5 WebSocket TTS", version="2.0.0")
+
+
+# WAV HEADER
+
+
+def wav_header(sample_rate: int, channels: int = 1, bits: int = 16) -> bytes:
+    byte_rate = sample_rate * channels * bits // 8
+    block_align = channels * bits // 8
+    return (
+        b"RIFF"
+        + (b"\xff\xff\xff\xff")
+        + b"WAVEfmt "
+        + (16).to_bytes(4, "little")
+        + (1).to_bytes(2, "little")
+        + channels.to_bytes(2, "little")
+        + sample_rate.to_bytes(4, "little")
+        + byte_rate.to_bytes(4, "little")
+        + block_align.to_bytes(2, "little")
+        + bits.to_bytes(2, "little")
+        + b"data"
+        + (b"\xff\xff\xff\xff")
+    )
+
+
+# STREAM CORE
+
+
+async def stream_lfm_tts(websocket: WebSocket, text: str):
+    chat = ChatState(processor)
+
+    chat.new_turn("system")
+    chat.add_text("Respond with interleaved text and audio.")
+    chat.end_turn()
+
+    chat.new_turn("user")
+    chat.add_text(text)
+    chat.end_turn()
+
+    chat.new_turn("assistant")
+
+    await websocket.send_bytes(wav_header(SAMPLE_RATE))
+
+    audio_buffer = []
+    stop_flag = False
+
+    async def listen_for_stop():
+        nonlocal stop_flag
+        try:
+            while True:
+                msg = await websocket.receive_text()
+                data = json.loads(msg)
+                if data.get("type") == "stop":
+                    stop_flag = True
+                    break
+        except:
+            stop_flag = True
+
+    listener_task = asyncio.create_task(listen_for_stop())
+
+    try:
+        with torch.inference_mode():
+            for token in model.generate_interleaved(
+                **chat,
+                max_new_tokens=4096,
+                audio_temperature=0.8,
+                audio_top_k=4,
+            ):
+                if stop_flag:
+                    break
+
+                if token.numel() == 1:
+                    continue
+
+                audio_buffer.append(token)
+
+                if len(audio_buffer) >= CHUNK_SIZE:
+                    audio_codes = (
+                        torch.stack(audio_buffer, dim=1)
+                        .unsqueeze(0)
+                        .to(DEVICE)
+                    )
+
+                    waveform = processor.decode(audio_codes)
+                    waveform = waveform.squeeze().cpu().numpy()
+                    waveform = np.clip(waveform, -1.0, 1.0)
+                    audio_int16 = (waveform * 32767.0).astype(np.int16)
+
+                    await websocket.send_bytes(audio_int16.tobytes())
+                    audio_buffer.clear()
+
+        # flush
+        if not stop_flag and len(audio_buffer) > 1:
+            audio_codes = (
+                torch.stack(audio_buffer[:-1], dim=1)
+                .unsqueeze(0)
+                .to(DEVICE)
+            )
+            waveform = processor.decode(audio_codes)
+            waveform = waveform.squeeze().cpu().numpy()
+            waveform = np.clip(waveform, -1.0, 1.0)
+            audio_int16 = (waveform * 32767.0).astype(np.int16)
+
+            await websocket.send_bytes(audio_int16.tobytes())
+
+        await websocket.send_text(json.dumps({"type": "done"}))
+
+    finally:
+        listener_task.cancel()
+
+
+# WEBSOCKET ENDPOINT
+
+
+@app.websocket("/ws/tts")
+async def websocket_tts(websocket: WebSocket):
+    await websocket.accept()
+
+    try:
+        while True:
+            message = await websocket.receive_text()
+            payload = json.loads(message)
+
+            if payload.get("type") == "start":
+                text = payload.get("text", "").strip()
+                if not text:
+                    await websocket.send_text(json.dumps({
+                        "type": "error",
+                        "message": "Text is empty"
+                    }))
+                    continue
+
+                await stream_lfm_tts(websocket, text)
+
+    except WebSocketDisconnect:
+        print("Client disconnected")

requirements.txt

@@ -0,0 +1,13 @@
+torchaudio
+soundfile
+accelerate
+huggingface_hub==0.23.2
+sentencepiece
+tokenizers
+fastapi==0.110.0
+uvicorn[standard]==0.27.1
+torch==2.1.2
+numpy==1.26.4
+pydantic==2.6.4
+transformers==4.40.2
+liquid-audio