Upload 3 files

README.md

@@ -1,3 +1,64 @@
----
-license: apache-2.0
----
+# Kyutai TTS Handler pour Hugging Face Endpoints
+
+## Déploiement rapide
+
+1. **Créez un nouveau repo sur Hugging Face** : `daiemon12/kyutai-tts-endpoint`
+
+2. **Uploadez ces fichiers** :
+   - `handler.py`
+   - `requirements.txt`
+   - `README.md`
+
+3. **Configuration de l'endpoint** :
+
+```
+Model Repository: daiemon12/kyutai-tts-endpoint
+
+Hardware: Intel Sapphire Rapids - 8 vCPUs · 16 GB
+($0.268/h)
+
+Ou mieux (recommandé pour production):
+Hardware: NVIDIA T4 · 16GB VRAM
+(~$0.60/h mais BEAUCOUP plus rapide)
+
+Security: Protected ✅
+Autoscaling: 0 to 2 replicas
+Scale-to-zero: après 60 min ✅
+```
+
+## Utilisation
+
+```python
+import requests
+
+response = requests.post(
+    "https://xxxxx.endpoints.huggingface.cloud",
+    headers={"Authorization": f"Bearer {HF_TOKEN}"},
+    json={
+        "inputs": "Bonjour, ceci est un test de synthèse vocale.",
+        "parameters": {
+            "language": "fr",  # ou "en", ou "auto"
+            "speed": 1.0
+        }
+    }
+)
+
+audio_base64 = response.json()["audio"]
+```
+
+## Performances attendues
+
+- **Latence première requête** : ~10-15s (chargement modèle)
+- **Latence suivantes** : 200-400ms
+- **Qualité** : État de l'art pour FR/EN
+- **Streaming** : 220ms du texte au premier audio
+
+## Alternative simple
+
+Si vous voulez tester rapidement sans créer de repo :
+
+1. Allez sur https://huggingface.co/spaces
+2. Duplicate un Space TTS existant
+3. Modifiez pour utiliser Kyutai
+
+Mais pour production, utilisez l'endpoint avec ce handler !

handler.py

@@ -0,0 +1,136 @@
+"""
+Handler direct pour Kyutai TTS - Charge le modèle depuis le repo original
+Pas besoin de dupliquer le modèle !
+"""
+
+import torch
+import base64
+import io
+import numpy as np
+from typing import Dict, Any
+import soundfile as sf
+
+class EndpointHandler:
+    def __init__(self, path=""):
+        """
+        Initialise le handler en chargeant directement depuis kyutai/tts-1.6b-en_fr
+        """
+        from moshi.models import loaders
+        
+        # Détection du device
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"🔧 Initialisation sur {self.device}")
+        
+        # Charger le modèle directement depuis le repo original
+        print("📥 Chargement du modèle kyutai/tts-1.6b-en_fr...")
+        self.lm_model = loaders.get_pretrained_lm_model(
+            device=self.device,
+            repo_id="kyutai/tts-1.6b-en_fr"  # Charge depuis le repo original !
+        )
+        
+        print("✅ Modèle chargé avec succès!")
+        
+        # Config par défaut
+        self.sample_rate = 24000
+        self.default_speed = 1.0
+        
+    def __call__(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Traite les requêtes TTS
+        
+        Args:
+            data: {
+                "inputs": str - Le texte à synthétiser
+                "parameters": {
+                    "language": str - "fr", "en" ou "auto" (défaut: auto)
+                    "speed": float - Vitesse de parole (défaut: 1.0)
+                    "voice": int - ID du locuteur (défaut: 0)
+                }
+            }
+        
+        Returns:
+            {
+                "audio": str - Audio en base64 (WAV)
+                "sampling_rate": int - Taux d'échantillonnage
+                "duration": float - Durée en secondes
+            }
+        """
+        # Extraction des paramètres
+        text = data.get("inputs", "")
+        if not text:
+            raise ValueError("Le paramètre 'inputs' (texte) est requis")
+            
+        params = data.get("parameters", {})
+        language = params.get("language", "auto")
+        speed = params.get("speed", self.default_speed)
+        voice_id = params.get("voice", 0)
+        
+        # Détection automatique de la langue
+        if language == "auto":
+            # Détection simple basée sur les caractères
+            fr_chars = set("àâäéèêëïîôùûçœ")
+            has_french = any(c in text.lower() for c in fr_chars)
+            language = "fr" if has_french else "en"
+            print(f"🌍 Langue détectée: {language}")
+        
+        # Validation de la langue
+        if language not in ["fr", "en"]:
+            raise ValueError(f"Langue non supportée: {language}. Utilisez 'fr', 'en' ou 'auto'")
+        
+        try:
+            # Synthèse vocale
+            print(f"🎤 Synthèse TTS: {len(text)} caractères en {language}")
+            
+            with torch.no_grad():
+                # Générer l'audio
+                audio_tensor = self.lm_model.synthesize(
+                    text=text,
+                    language=language,
+                    speaker_id=voice_id,
+                    speed=speed
+                )
+            
+            # Convertir en numpy array
+            audio_np = audio_tensor.cpu().numpy()
+            
+            # Normaliser l'audio
+            audio_np = audio_np / np.max(np.abs(audio_np))
+            
+            # Convertir en WAV
+            buffer = io.BytesIO()
+            sf.write(buffer, audio_np, self.sample_rate, format='WAV')
+            buffer.seek(0)
+            
+            # Encoder en base64
+            audio_base64 = base64.b64encode(buffer.read()).decode('utf-8')
+            
+            # Calculer la durée
+            duration = len(audio_np) / self.sample_rate
+            
+            print(f"✅ Synthèse réussie: {duration:.2f}s d'audio généré")
+            
+            return {
+                "audio": audio_base64,
+                "sampling_rate": self.sample_rate,
+                "duration": duration,
+                "metadata": {
+                    "language": language,
+                    "voice_id": voice_id,
+                    "speed": speed,
+                    "text_length": len(text)
+                }
+            }
+            
+        except Exception as e:
+            print(f"❌ Erreur TTS: {str(e)}")
+            raise RuntimeError(f"Erreur lors de la synthèse: {str(e)}")
+    
+    def health_check(self) -> Dict[str, Any]:
+        """Vérification de santé de l'endpoint"""
+        return {
+            "status": "healthy",
+            "model": "kyutai/tts-1.6b-en_fr",
+            "device": str(self.device),
+            "languages": ["fr", "en"],
+            "sample_rate": self.sample_rate
+        }

requirements.txt

@@ -0,0 +1,8 @@
+# Requirements pour Kyutai TTS Handler
+torch>=2.0.0
+torchaudio>=2.0.0
+moshi>=0.2.6
+numpy>=1.24.0
+huggingface-hub>=0.19.0
+safetensors>=0.4.0
+wave