Create README.md

README.md

@@ -0,0 +1,307 @@
+---
+license: mit
+language:
+- fr
+pipeline_tag: text-generation
+tags:
+- child
+- Alphabet
+- récitation
+- Simulation enfantine
+- ABX
+- simulation de ABX
+- jeunes enfants
+- 2 a 7 ans
+---
+# 🦋 ABX 
+
+![Abx-enfant](http://www.image-heberg.fr/files/17607941632935356724.jpg)
+
+Bienvenue sur la page de notre modèle `ABX`.
+Ce modèle de machine learning est une idée que Nous avions prototyper avec des règles.
+Mais nous avons considéré l'idée assez créative et intéressante pour faire l'objet de la création d'une IA de ML (machine learning),
+Et d'une version finale fonctionnelle concrète pour l'utilisation.
+
+## 🌷 Ce que fait ABX
+
+ABX est une IA qui simule la récitation de l'alphabet par un jeune enfant âgé de 2 a 7 ans.
+L'enfant (ABX) essaye de réciter l'alphabet,
+Mais plus son âge est faible et plus sa température est élevé, plus il oublie les lettres et se trompe.
+Il aura tendance à s'excuser, à pleurer ou à sauter des lettres quand il est en bas âge (2 ou 3 ans), et se tromper de façon perpétuelle.
+Mais ABX, sera extrêmement précis et fera un sans faute quand il est beaucoup plus grand (7 ans).
+ Plus sa température est élevée, et plus il est jeune, plus il va faire des boulettes (a l'image d'un vrai enfant).
+Un bébé de 2 ans ne sais pas réciter l'alphabet, mais un enfant de 7 ans sais le faire (enfin normalement 😉).
+ABX simule donc cela.
+
+# 🌸 Comment ABX a été entraîné 
+
+ABX a été entraîné de façon rapide, 
+Mais a quand même nécessiter l'activation du GPU pour un entraînement efficace et continue sans plantage de session.
+Pour qu'il apprenne à simuler la récitation de  des jeunes enfants,
+nous lui avons montrer l'alphabet correcte en entier,
+puis lui avons aussi donner des données d'entraînement pour les probabilités pour chaque âge.
+Nous avons aussi ajouté des petits messages aléatoires d'excuses, de pleurs et autre...que ABX utilise de temps et autres pour s'excuser et mettre de l'action a sa récitation foireuse de ses bas âge.
+
+# 🔥 Que faire avec ABX 
+
+ABX peut vous être utile pour beaucoup de tâches créatives impliquant de la simulation enfantine.
+(Par exemple : jeux de récitation l'alphabet ou les enfants qui doivent réciter l'alphabet sont des bots gérer par le modèle).
+Trouvez votre propre cas d'usage et amusez vous !
+
+# 🩵 Utilisation 
+
+Voici un exemple de code d'utilisation de ABX :
+
+```
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import json
+import os
+from huggingface_hub import hf_hub_download
+
+# =================================================================
+# 0. CONFIGURATION ET DÉFINITION DES CLASSES DU MODÈLE
+# =================================================================
+
+# --- Configuration du dépôt Hugging Face ---
+HF_REPO_ID = "Clemylia/ABX"
+MODEL_FILENAME = "abx_model_state.pt"
+CONFIG_FILENAME = "config.json"
+VOCAB_FILENAME = "vocab.json"
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+print(f"Périphérique utilisé : {DEVICE}")
+
+# --- Définition des classes du modèle (Doit être identique à l'entraînement !) ---
+
+# 1. Attention (Self-Attention Masquée Causale)
+class Attention(nn.Module):
+    def __init__(self, embed_dim, num_heads, dropout):
+        super().__init__()
+        self.norm = nn.LayerNorm(embed_dim)
+        self.attn = nn.MultiheadAttention(embed_dim, num_heads, dropout=dropout, batch_first=True)
+        self.dropout_rate = dropout
+
+    def forward(self, x, mask):
+        res = x
+        x = self.norm(x)
+        attn_output, _ = self.attn(x, x, x, attn_mask=mask, need_weights=False)
+        return res + attn_output
+
+# 2. Feed Forward (MLP)
+class FeedForward(nn.Module):
+    def __init__(self, embed_dim, d_ff, dropout):
+        super().__init__()
+        self.norm = nn.LayerNorm(embed_dim)
+        self.ffn = nn.Sequential(
+            nn.Linear(embed_dim, d_ff),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(d_ff, embed_dim),
+            nn.Dropout(dropout)
+        )
+
+    def forward(self, x):
+        res = x
+        x = self.norm(x)
+        return res + self.ffn(x)
+
+# 3. Bloc Décodeur
+class DecoderBlock(nn.Module):
+    def __init__(self, embed_dim, num_heads, d_ff, dropout):
+        super().__init__()
+        self.attention = Attention(embed_dim, num_heads, dropout)
+        self.feed_forward = FeedForward(embed_dim, d_ff, dropout)
+
+    def forward(self, x, mask):
+        x = self.attention(x, mask)
+        x = self.feed_forward(x, )
+        return x
+
+# 4. Le Modèle ABX Principal
+class ABXModel(nn.Module):
+    def __init__(self, vocab_size, embed_dim, num_heads, num_layers, max_seq_len, d_ff, pad_token_id, dropout=0.1):
+        super().__init__()
+        self.pad_token_id = pad_token_id
+        self.token_embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=pad_token_id)
+        self.position_embedding = nn.Embedding(max_seq_len, embed_dim)
+        self.dropout = nn.Dropout(dropout)
+
+        self.layers = nn.ModuleList([
+            DecoderBlock(embed_dim, num_heads, d_ff, dropout) for _ in range(num_layers)
+        ])
+
+        self.norm = nn.LayerNorm(embed_dim)
+        self.output_linear = nn.Linear(embed_dim, vocab_size)
+
+    def creer_masque(self, taille):
+        masque = torch.triu(torch.ones(taille, taille), diagonal=1).bool().to(DEVICE)
+        return masque
+
+    def forward(self, input_ids):
+        T = input_ids.size(1)
+
+        token_embed = self.token_embedding(input_ids)
+        positions = torch.arange(T, device=DEVICE).unsqueeze(0)
+        pos_embed = self.position_embedding(positions)
+
+        x = self.dropout(token_embed + pos_embed)
+
+        masque_causal = self.creer_masque(T)
+
+        for layer in self.layers:
+            x = layer(x, masque_causal)
+
+        x = self.norm(x)
+        logits = self.output_linear(x)
+
+        return logits
+
+
+# =================================================================
+# 1. TÉLÉCHARGEMENT DES FICHIERS DE CONFIGURATION ET DES POIDS
+# =================================================================
+
+print("Téléchargement des fichiers du dépôt Hugging Face...")
+
+# Télécharger les fichiers
+config_path = hf_hub_download(repo_id=HF_REPO_ID, filename=CONFIG_FILENAME)
+vocab_path = hf_hub_download(repo_id=HF_REPO_ID, filename=VOCAB_FILENAME)
+model_weights_path = hf_hub_download(repo_id=HF_REPO_ID, filename=MODEL_FILENAME)
+
+# --- Chargement de la Configuration ---
+with open(config_path, 'r') as f:
+    config = json.load(f)
+
+# --- Chargement du Vocabulaire ---
+with open(vocab_path, 'r') as f:
+    # Le vocabulaire a été sauvegardé comme un mapping ID -> Token (string)
+    id_to_token_str_keys = json.load(f)
+
+# Reconstruire le mapping Token -> ID pour l'inférence
+# Convertir les clés en int
+id_to_token = {int(k): v for k, v in id_to_token_str_keys.items()}
+token_to_id = {v: k for k, v in id_to_token.items()}
+
+
+# --- Extraction des paramètres ---
+VOCAB_SIZE = config['vocab_size']
+EMBED_DIM = config['embed_dim']
+NUM_HEADS = config['num_heads']
+NUM_LAYERS = config['num_layers']
+MAX_SEQ_LEN = config['max_seq_len']
+D_FF = config['d_ff']
+PAD_TOKEN_ID = config['pad_token_id']
+
+# Extraction des tokens spéciaux
+START_TOKEN = config['special_tokens']['start']
+END_TOKEN = config['special_tokens']['end']
+SEP_TOKEN = config['special_tokens']['sep']
+PAD_TOKEN = config['special_tokens']['pad']
+
+
+# =================================================================
+# 2. INSTANCIATION ET CHARGEMENT DU MODÈLE
+# =================================================================
+
+# Instanciation du modèle ABX
+model = ABXModel(
+    vocab_size=VOCAB_SIZE,
+    embed_dim=EMBED_DIM,
+    num_heads=NUM_HEADS,
+    num_layers=NUM_LAYERS,
+    max_seq_len=MAX_SEQ_LEN,
+    d_ff=D_FF,
+    pad_token_id=PAD_TOKEN_ID
+).to(DEVICE)
+
+# Chargement des poids entraînés
+model.load_state_dict(torch.load(model_weights_path, map_location=DEVICE))
+model.eval() # Toujours passer en mode évaluation pour l'inférence
+
+print("\nModèle et configuration chargés avec succès !")
+
+# =================================================================
+# 3. FONCTION DE GÉNÉRATION (Inférence)
+# =================================================================
+
+@torch.no_grad()
+def generer_recitation(model, age: int, temperature: float):
+    """
+    Génère une récitation de l'alphabet à partir de l'âge et de la température.
+    """
+    model.eval()
+
+    # Création du prompt initial
+    prompt_text = f"{START_TOKEN} [AGE:{age}] {SEP_TOKEN}"
+    prompt_tokens = prompt_text.split()
+
+    # Conversion en IDs
+    input_ids = [token_to_id.get(token, PAD_TOKEN_ID) for token in prompt_tokens]
+    input_tensor = torch.tensor([input_ids], dtype=torch.long, device=DEVICE)
+    output_ids = input_ids[:]
+
+    # Boucle de génération
+    for _ in range(len(prompt_tokens), MAX_SEQ_LEN):
+
+        logits = model(input_tensor)
+        next_token_logits = logits[0, -1, :]
+
+        # Application de la Température (échantillonnage)
+        if temperature <= 0.01:
+            next_token_id = torch.argmax(next_token_logits).item()
+        else:
+            probabilities = F.softmax(next_token_logits / temperature, dim=-1)
+
+            if torch.isnan(probabilities).any() or probabilities.sum() == 0:
+                next_token_id = torch.argmax(next_token_logits).item()
+            else:
+                next_token_id = torch.multinomial(probabilities, num_samples=1).item()
+
+        # Condition d'arrêt
+        if id_to_token.get(next_token_id) == END_TOKEN:
+            break
+
+        output_ids.append(next_token_id)
+
+        # Mise à jour de la séquence d'entrée
+        next_token_tensor = torch.tensor([[next_token_id]], dtype=torch.long, device=DEVICE)
+        input_tensor = torch.cat([input_tensor, next_token_tensor], dim=1)
+
+    # Conversion en texte et nettoyage
+    output_text = " ".join([id_to_token.get(id) for id in output_ids])
+    output_text = output_text.replace(f"{START_TOKEN} [AGE:{age}] {SEP_TOKEN}", "").replace(END_TOKEN, "").replace(PAD_TOKEN, "").strip()
+
+    return output_text
+
+
+# =================================================================
+# 4. EXEMPLES D'UTILISATION POUR L'UTILISATEUR
+# =================================================================
+
+print("\n" + "="*50)
+print("             TESTS UTILISATEUR ABX")
+print("="*50)
+
+# Scénario 1: L'enfant ne se concentre pas (Age bas, Température haute)
+age_test_1 = 2
+temp_test_1 = 1.3
+result_1 = generer_recitation(model, age_test_1, temp_test_1)
+print(f"-> Âge: {age_test_1} ans, Température: {temp_test_1} (Distrait)")
+print(f"Récitation: {result_1}\n")
+
+# Scénario 2: L'enfant fait un effort (Age moyen, Température modérée)
+age_test_2 = 5
+temp_test_2 = 0.7
+result_2 = generer_recitation(model, age_test_2, temp_test_2)
+print(f"-> Âge: {age_test_2} ans, Température: {temp_test_2} (Normal)")
+print(f"Récitation: {result_2}\n")
+
+# Scénario 3: L'enfant est très attentif (Age haut, Température basse)
+age_test_3 = 7
+temp_test_3 = 0.1
+result_3 = generer_recitation(model, age_test_3, temp_test_3)
+print(f"-> Âge: {age_test_3} ans, Température: {temp_test_3} (Précis)")
+print(f"Récitation: {result_3}")
+```