kokoclone

Dockerfile

@@ -1,7 +1,27 @@
-FROM python:3.11-slim
+FROM python:3.12.12
+
+# Évite la création de fichiers .pyc et active les logs en temps réel
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+# Définit le répertoire de travail
 WORKDIR /app
-RUN apt-get update && apt-get install -y ffmpeg && rm -rf /var/lib/apt/lists/*
+
+# Met à jour pip et installe les dépendances système légères
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Installe les dépendances Python
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
-COPY . .
+
+# Copie le code source
+COPY app.py .
+
+# Expose le port sur lequel l'API tourne
+EXPOSE 7860
+
+# Commande de démarrage du serveur
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,93 +1,92 @@
-import io
-import numpy as np
-import soundfile as sf
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import Response
-from pydantic import BaseModel
-from huggingface_hub import hf_hub_download
-from llama_cpp import Llama
-
-print("🚀 Démarrage MOSS-TTS-Nano GGUF (4-bit)")
-
-# --- Téléchargement du modèle GGUF ---
-GGUF_REPO = "John9007/MOSS-TTS-Local-GGUF"
-GGUF_FILE = "moss-tts-local-Q4_K_M.gguf"
-
-model_path = hf_hub_download(
-    repo_id=GGUF_REPO,
-    filename=GGUF_FILE,
-    cache_dir="/app/cache"
-)
-print(f"✅ Modèle téléchargé : {model_path}")
-
-# --- Chargement du modèle avec llama-cpp-python ---
-# (Note : l'inférence TTS avec ce binaire n'est pas encore totalement stable.
-#  À ce stade, nous utilisons le modèle pour une génération de test.
-#  Pour un usage réel, il faudra intégrer la chaîne d'inférence complète.)
-llm = Llama(
-    model_path=model_path,
-    n_ctx=512,
-    n_threads=2,
-    verbose=False
-)
-print("✅ Modèle chargé")
-
-# --- Clonage vocal ---
-VOICE_PROMPTS = {
-    "fr": "assets/fr_prompt.wav",   # À remplacer par le vrai prompt
-    "en": "assets/en_prompt.wav"
-}
-cloned_voices = {}
-
-# --- FastAPI ---
-app = FastAPI(title="MOSS-TTS-Nano API", version="1.0")
-
-class TTSRequest(BaseModel):
-    text: str
-    voice: str = "fr"   # "fr" ou "en"
-    speed: float = 1.0
-
-def generate_tts(text, voice, speed=1.0):
-    """
-    Fonction de génération TTS à partir du modèle MOSS-TTS-Nano.
-    ⚠️  Actuellement, cette fonction retourne un signal de test.
-    Pour intégrer la véritable synthèse, il faut utiliser la chaîne d'inférence
-    complète (tokenizer + audio tokenizer + génération par llama.cpp),
-    comme montrée dans la documentation du dépôt MOSS-TTS-Nano.
-    """
-    # TODO: Remplacer par l'appel réel au modèle.
-    # Pour l'exemple, on génère un son test.
-    sample_rate = 24000
-    duration = 3.0
-    t = np.linspace(0, duration, int(sample_rate * duration))
-    audio = 0.5 * np.sin(2 * np.pi * 440 * t)
-    audio = (audio * 32767).astype(np.int16)
-    return audio, sample_rate
-
-@app.post("/tts")
-async def tts(request: TTSRequest):
+import os
+import tempfile
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form
+from fastapi.responses import FileResponse, StreamingResponse
+from pydantic import BaseModel, HttpUrl
+import requests
+from pathlib import Path
+import time
+
+# Initialisation
+print("🚀 Démarrage du serveur FastAPI pour KokoClone...")
+
+# 1. Configuration du chemin pour les modèles et les sorties
+MODEL_DIR = Path("/app/cache/models")
+MODEL_DIR.mkdir(parents=True, exist_ok=True)
+OUTPUT_DIR = Path("/app/tmp")
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# 2. Télécharger le modèle cloner.py depuis le dépôt officiel si non présent
+CLONER_URL = "https://raw.githubusercontent.com/Ashish-Patnaik/kokoclone/main/core/cloner.py"
+CLONER_PATH = MODEL_DIR / "cloner.py"
+
+if not CLONER_PATH.exists():
+    print(f"⏳ Téléchargement de {CLONER_URL}...")
+    response = requests.get(CLONER_URL)
+    response.raise_for_status()
+    CLONER_PATH.write_text(response.text)
+    print("✅ cloner.py téléchargé avec succès.")
+
+# 3. Ajouter le chemin des modèles au PYTHONPATH pour l'import
+import sys
+sys.path.insert(0, str(MODEL_DIR))
+
+# 4. Importer et initialiser KokoClone
+from cloner import KokoClone
+
+print("⏳ Initialisation de KokoClone (première exécution, téléchargement des modèles)...")
+cloner = KokoClone()
+print("✅ KokoClone prêt à l'emploi.")
+
+app = FastAPI(title="KokoClone API", version="1.0")
+
+@app.get("/")
+async def root():
+    return {"status": "OK", "model": "KokoClone"}
+
+@app.post("/clone")
+async def clone_voice(
+    text: str = Form(...),
+    lang: str = Form(...),
+    audio_file: UploadFile = File(...)
+):
+    # 1. Sauvegarde temporaire du fichier audio de référence
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_ref:
+        content = await audio_file.read()
+        tmp_ref.write(content)
+        ref_path = tmp_ref.name
+
+    # 2. Définition du chemin de sortie
+    output_filename = f"output_{int(time.time())}.wav"
+    output_path = OUTPUT_DIR / output_filename
+
     try:
-        audio, sr = generate_tts(request.text, request.voice, request.speed)
-        buffer = io.BytesIO()
-        sf.write(buffer, audio, sr, format="WAV")
-        buffer.seek(0)
-        return Response(content=buffer.read(), media_type="audio/wav")
-    except Exception as e:
-        raise HTTPException(500, detail=str(e))
+        # 3. Appel à KokoClone pour la génération
+        cloner.generate(
+            text=text,
+            lang=lang,
+            reference_audio=ref_path,
+            output_path=str(output_path)
+        )
 
-@app.get("/clone")
-async def clone_voice(voice_name: str, lang: str = "fr"):
-    # À implémenter : utilisation d'un prompt audio externe
-    if voice_name not in cloned_voices:
-        cloned_voices[voice_name] = lang
-        return {"message": f"Voix '{voice_name}' clonée avec succès."}
-    else:
-        raise HTTPException(400, "Cette voix existe déjà")
+        # 4. Nettoyage du fichier temporaire de référence
+        os.unlink(ref_path)
+
+        # 5. Retour du fichier audio généré
+        return FileResponse(
+            path=str(output_path),
+            media_type="audio/wav",
+            filename=output_filename
+        )
+
+    except Exception as e:
+        # Nettoyage en cas d'erreur
+        if os.path.exists(ref_path):
+            os.unlink(ref_path)
+        if output_path.exists():
+            output_path.unlink()
+        raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/voices")
 async def list_voices():
-    return {"builtin": ["fr", "en"], "cloned": list(cloned_voices.keys())}
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    return {"languages": ["en", "hi", "fr", "ja", "zh", "it", "es", "pt"]}

requirements.txt

@@ -1,6 +1,10 @@
 fastapi
 uvicorn[standard]
-huggingface-hub
-llama-cpp-python
-numpy
 soundfile
+huggingface_hub
+torch
+torchaudio
+kokoro-onnx
+misaki[en,ja,zh]
+git+https://github.com/frothywater/kanade-tokenizer
+numpy