Clemylia/Prenma-IA-Name-Generator

🚀 Prenma-IA : Générateur de Noms Uniques par LSTM

✨ 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 :

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 :

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 :

# (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

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.