Update README.md

README.md

@@ -84,4 +84,241 @@ model_path = hf_hub_download(repo_id="Clemyllia/Liquy-Neko-CharRNN", filename="l
 **Amusez-vous bien avec Liquy-Neko \!** N'hésitez pas à partager vos créations les plus folles dans la communauté \! 💖✨
 
 **Lien site de documentation lovable** :
-https://liquy-neko-docs.lovable.app/
+https://liquy-neko-docs.lovable.app/
+
+**Exemple de code d'utilisation** :
+
+```
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import re
+import sys
+import os
+import io
+import random
+# Installe la bibliothèque Hugging Face (nécessaire pour le téléchargement)
+# Si vous êtes dans un notebook, exécutez d'abord : !pip install -q huggingface_hub
+from huggingface_hub import hf_hub_download 
+
+REPO_ID = "Clemylia/Liquy-Neko"
+MODEL_FILE = 'liquy.pt'
+
+# Constantes de base (doivent correspondre à celles de l'entraînement Char-RNN)
+SOS_token = 0
+EOS_token = 1
+MAX_LENGTH = 30 
+HIDDEN_SIZE = 256
+
+# Configuration du périphérique
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Initialisation des variables globales
+input_lang = None
+output_lang = None
+encoder = None
+decoder = None
+global_temperature = 0.9 
+
+# Classe Lang (Vocabulaire générique pour Mots et Caractères)
+class Lang:
+    """Stocke le vocabulaire (tokens <-> index)."""
+    def __init__(self, name, is_char_mode=False):
+        self.name = name
+        self.is_char_mode = is_char_mode
+        self.token2index = {}
+        self.token2count = {}
+        self.index2token = {SOS_token: "SOS", EOS_token: "EOS"}
+        self.n_tokens = 2
+
+class EncoderRNN(nn.Module):
+    def __init__(self, input_size, hidden_size, dropout_p):
+        super(EncoderRNN, self).__init__()
+        self.hidden_size = hidden_size
+        self.embedding = nn.Embedding(input_size, hidden_size)
+        self.gru = nn.GRU(hidden_size, hidden_size)
+        self.dropout = nn.Dropout(dropout_p)
+
+    def forward(self, input, hidden):
+        embedded = self.embedding(input).view(1, 1, -1)
+        embedded = self.dropout(embedded)
+        output, hidden = self.gru(embedded, hidden)
+        return output, hidden
+
+    def initHidden(self, device):
+        return torch.zeros(1, 1, self.hidden_size, device=device)
+
+# Architecture du Décodeur (Char-RNN)
+class DecoderRNN(nn.Module):
+    def __init__(self, hidden_size, output_size, dropout_p):
+        super(DecoderRNN, self).__init__()
+        self.hidden_size = hidden_size
+        self.embedding = nn.Embedding(output_size, hidden_size)
+        self.gru = nn.GRU(hidden_size, hidden_size)
+        self.out = nn.Linear(hidden_size, output_size)
+        self.softmax = nn.LogSoftmax(dim=1)
+        self.dropout = nn.Dropout(dropout_p)
+
+    def forward(self, input, hidden):
+        output = self.embedding(input).view(1, 1, -1)
+        output = F.relu(output)
+        output = self.dropout(output)
+        output, hidden = self.gru(output, hidden)
+        output = self.softmax(self.out(output[0]))
+        return output, hidden
+
+def indexesFromSentence(lang, sentence):
+    """Convertit une phrase/clé en indices de tokens (mots ou caractères)."""
+    tokens = list(sentence) if lang.is_char_mode else sentence.split(' ')
+    return [lang.token2index[token] for token in tokens if token in lang.token2index]
+
+def load_model_from_hub():
+    """Télécharge le modèle depuis Hugging Face et le charge localement."""
+    global input_lang, output_lang, encoder, decoder, global_temperature
+    
+    try:
+        # TÉLÉCHARGEMENT DU FICHIER DEPUIS HUGGING FACE
+        print(f"Téléchargement de {MODEL_FILE} depuis {REPO_ID}...")
+        model_path = hf_hub_download(repo_id=REPO_ID, filename=MODEL_FILE)
+        print(f"✅ Fichier téléchargé à : {model_path}")
+        
+        # CHARGEMENT LOCAL
+        checkpoint = torch.load(model_path, map_location=DEVICE)
+        
+        # Récupère les configurations et les objets Lang
+        input_lang = checkpoint['input_lang']
+        output_lang = checkpoint['output_lang']
+        hidden_size = checkpoint['hidden_size']
+        dropout_rate = checkpoint['dropout_rate']
+        # Récupère la température, utilise une valeur élevée par défaut si non trouvée
+        global_temperature = checkpoint.get('temperature', 1.1) 
+
+        # Initialisation des modèles (utilise n_tokens de chaque objet Lang)
+        encoder = EncoderRNN(input_lang.n_tokens, hidden_size, dropout_rate).to(DEVICE)
+        decoder = DecoderRNN(hidden_size, output_lang.n_tokens, dropout_rate).to(DEVICE)
+
+        # Charge les poids
+        encoder.load_state_dict(checkpoint['encoder_state_dict'])
+        decoder.load_state_dict(checkpoint['decoder_state_dict'])
+
+        print(f"\n✅ Modèle 'Liquy-Neko' chargé depuis le Hub ! 💖")
+        print(f"Configuration : TEMP={global_temperature:.1f}, HIDDEN_SIZE={hidden_size}, DROPOUT={dropout_rate}")
+        return True
+
+    except Exception as e:
+        print(f"\n❌ ERREUR lors du chargement du modèle depuis le Hub. Vérifiez le REPO_ID et l'existence du fichier.")
+        print(f"Détail de l'erreur : {e}")
+        return False
+
+def evaluate(encoder, decoder, sentence, max_length=MAX_LENGTH, temperature=global_temperature):
+    """Génère une expression de CHAR-RNN en utilisant l'échantillonnage de température."""
+    encoder.eval()
+    decoder.eval()
+    
+    # Prépare la clé d'entrée pour le modèle
+    sentence_tokens = sentence.replace('_', ' ')
+    
+    with torch.no_grad():
+        # Vérification minimale du vocabulaire (pour éviter les crashs)
+        if not all(token in input_lang.token2index for token in sentence_tokens.split(' ')):
+             return "Clé inconnue du vocabulaire d'entrée."
+
+        input_tensor = torch.tensor(indexesFromSentence(input_lang, sentence_tokens), dtype=torch.long, device=DEVICE).view(-1, 1)
+        input_length = input_tensor.size(0)
+
+        encoder_hidden = encoder.initHidden(DEVICE)
+
+        # Phase Encodeur
+        for ei in range(input_length):
+            _, encoder_hidden = encoder(input_tensor[ei], encoder_hidden)
+
+        decoder_input = torch.tensor([[SOS_token]], device=DEVICE) 
+        decoder_hidden = encoder_hidden
+
+        decoded_chars = []
+
+        # Phase Décodeur - Génération par caractère (Char-RNN)
+        for di in range(max_length):
+            decoder_output, decoder_hidden = decoder(decoder_input, decoder_hidden)
+            
+            # Application de la Température pour l'aléa (créativité)
+            output_distribution = decoder_output.squeeze(0).div(temperature).exp()
+            
+            # Échantillonnage: choisit le prochain caractère
+            topi = torch.multinomial(output_distribution, 1)[0]
+            
+            if topi.item() == EOS_token:
+                break
+            else:
+                # Récupération du caractère
+                decoded_chars.append(output_lang.index2token[topi.item()])
+
+            decoder_input = topi.detach()
+
+        encoder.train()
+        decoder.train() 
+
+        return ''.join(decoded_chars)
+
+def generer_liquy_neko_interface(prompt):
+    """Analyse le prompt utilisateur, construit la clé et génère l'expression."""
+    
+    prompt_ton = prompt
+    prompt_texte = prompt
+    
+    # Logique d'extraction du ton et de la demande d'emoji
+    emoji_part = '_e' if 'emoji' in prompt_texte.lower() else '_ne'
+    
+    if 'un peu kawaii' in prompt_ton.lower(): input_key = 'un_peu_k'
+    elif 'peu kawaii' in prompt_ton.lower(): input_key = 'peu_k'
+    elif 'moyennement kawaii' in prompt_ton.lower(): input_key = 'moyennement_k'
+    elif 'hautement kawaii' in prompt_ton.lower(): input_key = 'hautement_k'
+    elif 'imaginaire' in prompt_ton.lower(): input_key = 'lang_imag'
+    else: input_key = 'moyennement_k'
+
+    final_key = input_key + emoji_part
+    
+    result = evaluate(encoder, decoder, final_key, temperature=global_temperature)
+    
+    print(f"\n--- Liquy-Neko - Création Unique ---")
+    print(f"Ton demandé: **{input_key.replace('_', ' ')}**")
+    print(f"Clé modèle utilisée: `{final_key.replace('_', ' ')}`")
+    print(f"Résultat: **{result}**")
+
+if __name__ == "__main__":
+    
+    print("\n" + "="*55)
+    print("     DÉMARRAGE DE LIQUY-NEKO (CHAR-RNN HUB TEST)     ")
+    print("="*55)
+
+    if not load_model_from_hub():
+        # Quitte si le chargement a échoué
+        sys.exit("Impossible de continuer sans charger le modèle.")
+
+    
+    print("\n[A] Tests Automatisés :")
+    generer_liquy_neko_interface("hautement kawaii avec des emojis")
+    generer_liquy_neko_interface("en langue imaginaire sans emojis")
+    
+    
+    print("\n" + "-"*55)
+    print("--- DÉMARRAGE DE L'INTERFACE INTERACTIVE ---")
+    print("Teste ta créature ! Exemples : 'peu kawaii', 'hautement kawaii emoji', 'imaginaire'.")
+    print("Tapez 'quitter' pour terminer.")
+    print("-"*55)
+
+    while True:
+        try:
+            user_input = input("Ton prompt (>): ")
+            if user_input.lower() in ['quitter', 'exit']:
+                print("Au revoir ! C'était génial de déployer ton modèle ! 👋")
+                break
+            
+            generer_liquy_neko_interface(user_input)
+            
+        except EOFError:
+            print("\nFin de l'entrée. Arrêt de l'interface. 👋")
+            break
+        except Exception as e:
+            print(f"Une erreur est survenue lors de la génération: {e}. Réessayez.")
+```