Upload 2 files

app.py

@@ -1,60 +1,148 @@
 import spaces
+from snac import SNAC
+import torch
 import gradio as gr
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from huggingface_hub import snapshot_download
 from dotenv import load_dotenv
-import numpy as np
-from orpheus_cpp import OrpheusCpp
 load_dotenv()
 
-# Initialiser le modèle Orpheus-CPP avec le modèle français original
-print("Chargement du modèle Orpheus-CPP...")
-try:
-    # Utilisez le même modèle français que précédemment
-    orpheus = OrpheusCpp(
-        model_path="canopylabs/3b-fr-ft-research_release",
-        context_size=2048,
-        gpu_layers=32  # Utiliser le GPU si disponible
-    )
-    print("Modèle Orpheus-CPP chargé avec succès")
-except Exception as e:
-    print(f"Erreur lors du chargement du modèle spécifié: {e}")
-    print("Tentative de chargement avec le modèle français par défaut...")
-    try:
-        orpheus = OrpheusCpp()
-        print("Modèle Orpheus-CPP chargé avec les paramètres par défaut")
-    except Exception as e:
-        print(f"Erreur lors du chargement du modèle par défaut: {e}")
-        print("Vérifiez l'installation d'orpheus-cpp et les dépendances")
+# Vérifier si CUDA est disponible
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+print("Chargement du modèle SNAC...")
+snac_model = SNAC.from_pretrained("hubertsiuzdak/snac_24khz")
+snac_model = snac_model.to(device)
+
+model_name = "canopylabs/3b-fr-ft-research_release"
+
+# Télécharger uniquement la configuration du modèle et les safetensors
+snapshot_download(
+    repo_id=model_name,
+    allow_patterns=[
+        "config.json",
+        "*.safetensors",
+        "model.safetensors.index.json",
+    ],
+    ignore_patterns=[
+        "optimizer.pt",
+        "pytorch_model.bin",
+        "training_args.bin",
+        "scheduler.pt",
+        "tokenizer.json",
+        "tokenizer_config.json",
+        "special_tokens_map.json",
+        "vocab.json",
+        "merges.txt",
+        "tokenizer.*"
+    ]
+)
+
+model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16)
+model.to(device)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+print(f"Modèle Orpheus chargé sur {device}")
+
+# Traiter le texte d'entrée
+def process_prompt(prompt, voice, tokenizer, device):
+    prompt = f"{voice}: {prompt}"
+    input_ids = tokenizer(prompt, return_tensors="pt").input_ids
+    
+    start_token = torch.tensor([[128259]], dtype=torch.int64)  # Début humain
+    end_tokens = torch.tensor([[128009, 128260]], dtype=torch.int64)  # Fin du texte, Fin humain
+    
+    modified_input_ids = torch.cat([start_token, input_ids, end_tokens], dim=1)  # SOH SOT Texte EOT EOH
+    
+    # Pas besoin de padding pour une seule entrée
+    attention_mask = torch.ones_like(modified_input_ids)
+    
+    return modified_input_ids.to(device), attention_mask.to(device)
+
+# Analyser les tokens de sortie en audio
+def parse_output(generated_ids):
+    token_to_find = 128257
+    token_to_remove = 128258
+    
+    token_indices = (generated_ids == token_to_find).nonzero(as_tuple=True)
+
+    if len(token_indices[1]) > 0:
+        last_occurrence_idx = token_indices[1][-1].item()
+        cropped_tensor = generated_ids[:, last_occurrence_idx+1:]
+    else:
+        cropped_tensor = generated_ids
 
-# Fonction principale de génération avec orpheus-cpp
+    processed_rows = []
+    for row in cropped_tensor:
+        masked_row = row[row != token_to_remove]
+        processed_rows.append(masked_row)
+
+    code_lists = []
+    for row in processed_rows:
+        row_length = row.size(0)
+        new_length = (row_length // 7) * 7
+        trimmed_row = row[:new_length]
+        trimmed_row = [t - 128266 for t in trimmed_row]
+        code_lists.append(trimmed_row)
+        
+    return code_lists[0]  # Retourner uniquement le premier pour un seul échantillon
+
+# Redistribuer les codes pour la génération audio
+def redistribute_codes(code_list, snac_model):
+    device = next(snac_model.parameters()).device  # Obtenir le périphérique du modèle SNAC
+    
+    layer_1 = []
+    layer_2 = []
+    layer_3 = []
+    for i in range((len(code_list)+1)//7):
+        layer_1.append(code_list[7*i])
+        layer_2.append(code_list[7*i+1]-4096)
+        layer_3.append(code_list[7*i+2]-(2*4096))
+        layer_3.append(code_list[7*i+3]-(3*4096))
+        layer_2.append(code_list[7*i+4]-(4*4096))
+        layer_3.append(code_list[7*i+5]-(5*4096))
+        layer_3.append(code_list[7*i+6]-(6*4096))
+        
+    # Déplacer les tenseurs vers le même périphérique que le modèle SNAC
+    codes = [
+        torch.tensor(layer_1, device=device).unsqueeze(0),
+        torch.tensor(layer_2, device=device).unsqueeze(0),
+        torch.tensor(layer_3, device=device).unsqueeze(0)
+    ]
+    
+    audio_hat = snac_model.decode(codes)
+    return audio_hat.detach().squeeze().cpu().numpy()  # Toujours retourner un tableau numpy CPU
+
+# Fonction principale de génération
 @spaces.GPU()
 def generate_speech(text, voice, temperature, top_p, repetition_penalty, max_new_tokens, progress=gr.Progress()):
     if not text.strip():
         return None
     
     try:
-        progress(0.2, "Traitement du texte...")
-        
-        # Configuration des options de génération
-        options = {
-            "voice_id": voice,
-            "temperature": temperature,
-            "top_p": top_p,
-            "repetition_penalty": repetition_penalty,
-            "max_tokens": max_new_tokens
-        }
+        progress(0.1, "Traitement du texte...")
+        input_ids, attention_mask = process_prompt(text, voice, tokenizer, device)
         
-        progress(0.5, "Génération audio...")
-        
-        # Génération avec orpheus-cpp
-        sample_rate, audio_samples = orpheus.tts(text, options=options)
+        progress(0.3, "Génération des tokens de parole...")
+        with torch.no_grad():
+            generated_ids = model.generate(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                max_new_tokens=max_new_tokens,
+                do_sample=True,
+                temperature=temperature,
+                top_p=top_p,
+                repetition_penalty=repetition_penalty,
+                num_return_sequences=1,
+                eos_token_id=128258,
+            )
         
-        progress(0.9, "Finalisation...")
+        progress(0.6, "Traitement des tokens de parole...")
+        code_list = parse_output(generated_ids)
         
-        # Convertir en tableau numpy si nécessaire
-        if not isinstance(audio_samples, np.ndarray):
-            audio_samples = np.array(audio_samples)
+        progress(0.8, "Conversion en audio...")
+        audio_samples = redistribute_codes(code_list, snac_model)
         
-        return (sample_rate, audio_samples)
+        return (24000, audio_samples)  # Retourner le taux d'échantillonnage et l'audio
     except Exception as e:
         print(f"Erreur lors de la génération de la parole: {e}")
         return None
@@ -87,11 +175,6 @@ with gr.Blocks(title="Orpheus Text-to-Speech") as demo:
     - Ajoutez des éléments paralinguistiques comme {", ".join(EMOTIVE_TAGS)} ou `euh` pour une parole plus humaine.
     - Les textes plus longs fonctionnent généralement mieux que les phrases très courtes
     - Augmenter `repetition_penalty` et `temperature` fait parler le modèle plus rapidement.
-    
-    ## Améliorations avec orpheus-cpp:
-    - Performances optimisées et temps de génération réduit
-    - Utilisation plus efficace de la mémoire
-    - Latence réduite pour une meilleure expérience utilisateur
     """)    
     with gr.Row():
         with gr.Column(scale=3):

requirements.txt

@@ -2,5 +2,4 @@ snac
 python-dotenv
 transformers
 torch
-spaces
-orpheus-cpp==0.0.3
+spaces