--- tags: - rnn - lstm - name-generation - pytorch license: mit language: - fr pipeline_tag: text-generation --- # 🚀 Prenma-IA : Générateur de Noms Uniques par LSTM ![Prenma](http://www.image-heberg.fr/files/1759943392350887428.jpg) ## ✨ Présentation du Modèle Bienvenue sur le dépôt de **Prenma-IA**, un générateur de noms basé sur un **Réseau de Neurones Récurrents (RNN)** de type **LSTM (Long Short-Term Memory)**. Ce modèle a été entraîné sur une liste de noms de haute qualité pour apprendre leur structure et leurs schémas phonétiques, lui permettant de créer des noms entièrement **originaux et uniques**. Que tu cherches des noms pour des personnages de fiction, des produits, ou des noms de domaine, Prenma-IA est là pour t'aider à trouver l'inspiration \! 💡 ----- ## 🛠️ Comment Utiliser Prenma-IA (PyTorch) Puisque ce modèle est un fichier de poids PyTorch (`.pth`) brut, tu auras besoin de la **structure du modèle (la classe `PrenmaIA`)** et des **fonctions de génération** pour l'utiliser. Voici les étapes concrètes pour télécharger le modèle et générer des noms en Python : ### 1\. 📥 Préparation de l'Environnement Installe les bibliothèques nécessaires : ```bash pip install torch huggingface_hub ``` ### 2\. 📝 Définition des Constantes et Classes Tu dois copier la structure du modèle (la classe `PrenmaIA`) et les fonctions auxiliaires (`name_to_tensor`, `make_char_dictionaries`, etc.) dans ton script Python. Ces éléments sont la **"recette"** nécessaire pour interpréter le fichier de poids. Voici les paramètres de la structure que tu dois réutiliser : | Paramètre | Valeur | Description | | :--- | :--- | :--- | | **`ALL_CHARS`** | `string.ascii_letters + " .,;'-"` | Le vocabulaire complet du modèle. | | **`HIDDEN_SIZE`** | `128` | La taille de la couche cachée de la LSTM. | | **`N_LAYERS`** | `2` | Le nombre de couches LSTM empilées. | *(**Note aux Utilisateurs :** Reporte-toi au script de chargement fourni sur ce dépôt ou dans le guide du développeur pour obtenir les définitions exactes des fonctions.)* ### 3\. 🌐 Charger le Modèle depuis Hugging Face Utilise la fonction `hf_hub_download` pour récupérer le fichier de poids (`.pth`) directement : ```python from huggingface_hub import hf_hub_download import torch # ... (Importer ta classe PrenmaIA et les constantes) REPO_ID = "Clemylia/Prenma-IA-Name-Generator" MODEL_FILENAME = "prenma_ia_lstm.pth" # Téléchargement model_path = hf_hub_download(repo_id=REPO_ID, filename=MODEL_FILENAME) # Initialisation du modèle vide model = PrenmaIA(input_size=len(ALL_CHARS), hidden_size=128, output_size=len(ALL_CHARS), n_layers=2) # Charger les poids model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu'))) model.eval() print("✅ Modèle Prenma-IA chargé avec succès !") ``` ### 4\. 💫 Générer un Nom Une fois le modèle chargé (`model`), tu peux appeler ta fonction de génération. La fonction clé est `generate(model, start_char, char_to_ix, ix_to_char, temperature=0.8)`. | Paramètre | Description | | :--- | :--- | | **`start_char`** | La lettre par laquelle le nom doit commencer (ex: `'A'`, `'k'`). | | **`temperature`** | (**Optionnel**) Contrôle la créativité. `0.0` (déterministe) à `1.5` (très aléatoire). **`0.8` est recommandé** pour un bon équilibre. | **Exemple d'utilisation :** ```python # (Assumant que char_to_ix et ix_to_char sont définis) # Générer un nom commençant par 'C' avec une créativité modérée nom_creatif = generate(model, 'C', char_to_ix, ix_to_char, temperature=0.85) print(f"Nom généré : {nom_creatif.capitalize()}") # Générer un nom commençant par 'Z' avec un caractère plus probable nom_stable = generate(model, 'Z', char_to_ix, ix_to_char, temperature=0.6) print(f"Nom généré : {nom_stable.capitalize()}") ``` ----- ## ⚙️ Hyperparamètres de Génération | Hyperparamètre | Rôle | Impact sur la Sortie | | :--- | :--- | :--- | | **`temperature`** | Contrôle l'aléa (entropie) des prédictions. | ⬆️ Plus chaud (proche de 1.0) = Noms plus originaux, mais potentiellement illisibles. ⬇️ Plus froid (proche de 0.0) = Noms plus prévisibles, basés sur les données d'entraînement. | | **Contrainte de Non-Répétition** | Le modèle est contraint de ne jamais choisir la même lettre deux fois de suite. | Évite les séquences comme 'aa', 'ee', 'll', rendant les noms plus fluides. | | **`MAX_LENGTH`** | Longueur maximale de la séquence de génération. | Affecte la longueur maximale du nom (incluant le caractère de départ). | ----- ## 🔗 Liens Utiles * [Documentation PyTorch](https://pytorch.org/docs/stable/index.html) **Créé par :** @Clemylia 🦋 exemple de code d'utilisation : ``` import torch import torch.nn as nn from huggingface_hub import hf_hub_download import string import random import os # --- Configuration du Modèle et du Hub --- # Assure-toi que ces valeurs correspondent à celles utilisées lors de la publication # RAPPEL : Le format est NOM_UTILISATEUR/NOM_DU_DÉPÔT FULL_REPO_ID = "Clemylia/Prenma-IA-Name-Generator" # <<< REMPLACE TON_NOM_UTILISATEUR ICI ! MODEL_FILENAME = "prenma_ia_lstm.pth" # --- Constantes du Modèle (Doivent être IDENTIQUES à l'entraînement) --- ALL_CHARS = string.ascii_letters + " .,;'-" N_CHARS = len(ALL_CHARS) MAX_LENGTH = 15 # Longueur de génération par défaut (tu peux ajuster) # Paramètres du modèle (identiques à l'entraînement) INPUT_SIZE = N_CHARS HIDDEN_SIZE = 128 OUTPUT_SIZE = N_CHARS N_LAYERS = 2 # --- Fonctions et Classe du Modèle (Copie de la structure PyTorch) --- def name_to_tensor(name, char_to_ix): """Convertit un nom (ou un seul caractère) en tenseur One-Hot.""" tensor = torch.zeros(len(name), 1, N_CHARS) for i, char in enumerate(name): tensor[i][0][char_to_ix[char]] = 1 return tensor def make_char_dictionaries(): """Crée les mappings de caractères (lettre -> index et index -> lettre).""" char_to_ix = {char: i for i, char in enumerate(ALL_CHARS)} ix_to_char = {i: char for i, char in enumerate(ALL_CHARS)} return char_to_ix, ix_to_char class PrenmaIA(nn.Module): """Modèle LSTM pour la génération de noms.""" def __init__(self, input_size, hidden_size, output_size, n_layers=1): super(PrenmaIA, self).__init__() self.hidden_size = hidden_size self.n_layers = n_layers self.lstm = nn.LSTM(input_size, hidden_size, n_layers) self.output_layer = nn.Linear(hidden_size, output_size) self.softmax = nn.LogSoftmax(dim=1) def forward(self, input_char, hidden_state, cell_state): output, (hidden_state, cell_state) = self.lstm(input_char, (hidden_state, cell_state)) output = self.output_layer(output.squeeze(0)) output = self.softmax(output) return output, hidden_state, cell_state def init_hidden(self): return torch.zeros(self.n_layers, 1, self.hidden_size) def init_cell(self): return torch.zeros(self.n_layers, 1, self.hidden_size) # --- Fonction de Génération (avec contrainte de non-répétition) --- def generate(model, start_char, char_to_ix, ix_to_char, temperature=0.8): """ Génère un nom complet en utilisant l'échantillonnage contrôlé par la température, et la contrainte de non-répétition immédiate. """ with torch.no_grad(): hidden = model.init_hidden() cell = model.init_cell() name_generated = start_char.lower() current_char = name_generated # Assurer que le caractère initial est un caractère valide pour le mapping if current_char not in char_to_ix: print(f"❌ Erreur: Le caractère de départ '{start_char}' n'est pas dans le vocabulaire.") return "Invalide" index_to_exclude = char_to_ix[current_char] eos_index = char_to_ix[' '] for i in range(MAX_LENGTH): input_char_tensor = name_to_tensor(current_char, char_to_ix) output, hidden, cell = model(input_char_tensor, hidden, cell) # Appliquer la température pour ajuster l'aléatoire (créativité) output_with_temp = output / temperature probabilities = torch.exp(output_with_temp) # Contrainte de non-répétition immédiate probabilities[0, index_to_exclude] = 0.0 # Normaliser et échantillonner probabilities = probabilities / probabilities.sum(dim=1, keepdim=True) topi = torch.multinomial(probabilities, 1)[0].item() if topi == eos_index: break else: char = ix_to_char[topi] name_generated += char current_char = char index_to_exclude = topi return name_generated # --- Logique de Chargement et d'Utilisation --- def load_and_use_model(): # 🌟 ÉTAPE 1: Téléchargement du fichier de poids depuis Hugging Face print(f"🔗 Téléchargement du modèle '{MODEL_FILENAME}' depuis {FULL_REPO_ID}...") try: # Télécharge le fichier dans le cache local de Hugging Face model_path = hf_hub_download(repo_id=FULL_REPO_ID, filename=MODEL_FILENAME) print(f"✅ Fichier modèle téléchargé : {model_path}") except Exception as e: print(f"❌ Erreur de téléchargement. As-tu bien remplacé 'TON_NOM_UTILISATEUR' ?") print(f"Détails : {e}") return # 🌟 ÉTAPE 2: Initialisation et chargement char_to_ix, ix_to_char = make_char_dictionaries() model = PrenmaIA(INPUT_SIZE, HIDDEN_SIZE, OUTPUT_SIZE, N_LAYERS) # Charger les poids dans le modèle model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu'))) model.eval() # Mode évaluation print("\n🎉 Modèle Prenma-IA prêt à générer des noms !") print("---------------------------------------------") # 🌟 ÉTAPE 3: Utilisation du modèle start_chars = ['C', 'L', 'Y', 'M', 'A'] print(f"Génération de {len(start_chars)} noms (Température=0.8, Longueur Max={MAX_LENGTH + 1})") for start in start_chars: # Utilisation d'une température par défaut de 0.8 generated_name = generate(model, start, char_to_ix, ix_to_char, temperature=0.8) print(f" -> {start}: {generated_name.capitalize()}") print("---------------------------------------------") # Lancement de la fonction principale load_and_use_model() ``` 🛑 **Cette IA a été entraîné avec une liste de 105 noms pour crée ses propres noms originaux, cependant, même si les noms générer sont des créations originales créé par notre IA, le modèle peut les resortir de nombreuses fois.**