--- 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}") ```