Update README.md

README.md

@@ -1,3 +1,374 @@
----
-license: mit
----
+---
+license: mit
+datasets:
+- Clem27sey/Nacid
+language:
+- fr
+pipeline_tag: text-generation
+tags:
+- ARICATE
+- Lam-2
+- Slm
+- Génération de texte
+- LAM
+- Aricate architecture
+---
+
+# 🚀 Lam-2 (Aricate V4) : Un SLM Coherent et Créatif
+
+![Lam-2](http://www.image-heberg.fr/files/17611484311798663078.jpg)
+
+**Lam-2** est la deuxième itération d'un **Small Language Model (SLM)** développé sous l'architecture personnalisée **Aricate V4**.
+
+Il a été entraîné pour exceller dans les tâches de **Question/Réponse (Q/A)** tout en assurant une **cohérence linguistique** supérieure. Lam-2 marque une avancée significative en passant d'une génération par tokens instable (Lam-1) à une génération de phrases complètes, grammaticalement parfaites, capables d'une grande **créativité** à haute température.
+
+| Caractéristique | Lam-1 (Legacy) | **Lam-2 (Aricate V4)** |
+| :--- | :--- | :--- |
+| **Architecture** | RNN Simple | **GRU + Attention Additive** |
+| **Cohérence** | Instable (mots illisibles) | **Élevée (Grammaire et Orthographe parfaites)** |
+| **Méthode d'Entraînement** | Séquentiel Simple | Préd. Mot Suivant (avec Padding) |
+| **Génération** | Beam Search Déterministe | **Beam Search & Top-K Sampling** |
+
+## 🎯 But du Modèle et Cas d'Usage
+
+Le Framework Aricate V4 vise à démontrer qu'une architecture légère et personnalisée peut générer des réponses pertinentes et originales.
+
+  * **Cas d'Usage Primaire :** Systèmes de Question/Réponse sur des bases de connaissances spécifiques (comme le jeu de données `Nacid` utilisé pour l'entraînement initial).
+  * **Potentiel Créatif :** Grâce au **Top-K Sampling** et à la **Température**, Lam-2 peut être ajusté pour générer des textes créatifs ou exploratoires tout en conservant une excellente syntaxe.
+
+-----
+
+## 🏗️ Architecture Aricate V4 : Clé de la Stabilité
+
+Le bond en avant en matière de cohérence linguistique (par rapport à Lam-1) est dû à l'intégration du mécanisme d'Attention dans une architecture récurrente solide.
+
+### 1\. Le Stabilisateur GRU (Gated Recurrent Unit)
+
+La GRU est responsable de la lecture de la séquence d'entrée (Question + `  <sep> `) et de la rétention de la mémoire contextuelle.
+
+  * Elle garantit la **cohésion grammaticale** : en apprenant les règles de l'ordre des mots, la GRU assure que le mot généré est syntaxiquement correct par rapport aux mots précédents. C'est pourquoi Lam-2 maintient une **orthographe et une structure de phrase impeccables**, même lorsque le contenu sémantique devient imprévisible.
+
+### 2\. Le Focalisateur d'Attention Additive
+
+Le mécanisme d'Attention (dit Bahdanau) est crucial pour la pertinence :
+
+  * Il permet au modèle de **pondérer l'importance** des mots de la question à chaque étape de la génération.
+  * En combinant le **Vecteur de Contexte** (ce sur quoi il faut se concentrer) avec l'**État Caché Final** (ce qu'il sait jusqu'à présent), Lam-2 produit des réponses qui se rapportent au sujet.
+
+-----
+
+## 🧪 Potentiel Créatif : Température et Sampling
+
+Lam-2 peut être exploité bien au-delà de la réponse déterministe grâce à ses paramètres d'inférence avancés.
+
+### 1\. Le Mode Déterministe (Cohérence Maximale)
+
+  * **Méthode :** **Beam Search**
+  * **Résultat :** Le modèle explore plusieurs chemins de phrase, mais choisit la séquence la plus probable. Idéal pour les réponses factuelles et précises.
+
+### 2\. Le Mode Créatif (Potentiel Émergent) 💡
+
+Lam-2 excelle dans l'exploration linguistique lorsque les paramètres de génération sont ajustés. C'est là que réside son potentiel créatif et sa capacité à générer des phrases **originales** :
+
+| Paramètre | Valeur Typique | Effet sur Lam-2 |
+| :--- | :--- | :--- |
+| **`temperature`** | **$1.1$ à $1.3$ (Haute)** | Rend le modèle **moins prédictif** et plus aventureux, augmentant la probabilité de choisir des mots peu fréquents. (Peut conduire à des "délires originaux" si trop élevée). |
+| **`top_k`** | **$10$ à $30$** | Limite le choix aléatoire aux **$K$ mots les plus probables**, ce qui maintient le délire dans un cadre linguistique pertinent et évite les séquences inutilisables. |
+
+En utilisant une **haute température**, Lam-2 génère des séquences qui **n'existaient pas dans la *dataset***, prouvant qu'il a internalisé les règles de la langue pour composer de nouvelles phrases.
+
+-----
+
+## 🛠️ Utilisation Avancée : Chargement du Modèle
+
+Lam-2 est publié sous format **Safetensors** pour un chargement sécurisé et rapide.
+
+### Installation
+
+```bash
+pip install torch huggingface_hub safetensors
+```
+
+### Chargement et Génération (Mode Créatif)
+
+L'utilisation d'une fonction d'inférence personnalisée est nécessaire pour manipuler le **`WordTokenizer`** Aricate et les paramètres d'échantillonnage.
+
+```python
+# Nécessite les classes AricateModel et WordTokenizer pour fonctionner.
+from your_aricate_library import AricateModel, WordTokenizer, generate_sequence, load_lam2_model 
+
+LAM2_REPO_ID = "Clemylia/lam-2"
+
+# 1. Chargement du modèle
+lam2_model, lam2_tokenizer, max_len = load_lam2_model(LAM2_REPO_ID)
+
+# 2. Test en mode créatif
+question = "Pourquoi l'architecture Aricate est-elle si géniale ?"
+
+generate_sequence(
+    model=lam2_model,
+    tokenizer=lam2_tokenizer,
+    question=question,
+    max_length=20,
+    max_len_input=max_len,
+    temperature=1.2,   # Pour plus de créativité !
+    top_k=15           # Pour un choix limité aux 15 meilleurs mots.
+)
+```
+
+**[Lien vers le Code Source Complet d'Aricate sur GitHub]**
+
+-----
+
+**Développé par :** (Clemylia)
+**Dataset d'Entraînement :** `Clem27sey/Nacid` (Q/A)
+**License :** MIT
+
+exemple d'inférence :
+
+```
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import json
+import os
+import collections
+import heapq
+# Importations des librairies nécessaires pour le chargement
+from huggingface_hub import hf_hub_download
+from safetensors.torch import load_file as load_safetensors_file
+
+# --- A. AricateAttentionLayer (Inchangé) ---
+class AricateAttentionLayer(nn.Module):
+    # ... (code inchangé) ...
+    """Couche d'Attention Additive (Bahdanau)."""
+    def __init__(self, hidden_dim):
+        super(AricateAttentionLayer, self).__init__()
+        self.W = nn.Linear(hidden_dim, hidden_dim)
+        self.U = nn.Linear(hidden_dim, hidden_dim)
+        self.V = nn.Linear(hidden_dim, 1, bias=False)
+    def forward(self, rnn_outputs, last_hidden):
+        last_hidden_expanded = last_hidden.unsqueeze(1)
+        energy = torch.tanh(self.W(rnn_outputs) + self.U(last_hidden_expanded))
+        attention_weights_raw = self.V(energy).squeeze(2)
+        attention_weights = F.softmax(attention_weights_raw, dim=1)
+        context_vector = torch.sum(rnn_outputs * attention_weights.unsqueeze(2), dim=1)
+        return context_vector
+
+# --- B. AricateModel (Inchangé) ---
+class AricateModel(nn.Module):
+    # ... (code inchangé) ...
+    """Architecture Aricate V4, adaptée pour le rechargement."""
+    def __init__(self, vocab_size: int, embedding_dim: int, hidden_dim: int, num_layers: int = 1, config: dict = None):
+        super(AricateModel, self).__init__()
+
+        if config is not None:
+             vocab_size = config.get("vocab_size", vocab_size)
+             embedding_dim = config.get("embedding_dim", embedding_dim)
+             hidden_dim = config.get("hidden_dim", hidden_dim)
+             num_layers = config.get("num_layers", num_layers)
+
+        self.vocab_size = vocab_size
+        self.embedding_dim = embedding_dim
+        self.hidden_dim = hidden_dim
+        self.num_layers = num_layers
+
+        self.word_embeddings = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim, padding_idx=0)
+        self.rnn = nn.GRU(input_size=embedding_dim, hidden_size=hidden_dim, num_layers=num_layers, batch_first=True)
+        self.attention = AricateAttentionLayer(hidden_dim)
+        self.hidden_to_vocab = nn.Linear(hidden_dim * 2, vocab_size)
+
+    def forward(self, input_words):
+        embeds = self.word_embeddings(input_words)
+        rnn_out, hn = self.rnn(embeds)
+        last_hidden = hn[-1]
+        context_vector = self.attention(rnn_out, last_hidden)
+        combined_features = torch.cat((context_vector, last_hidden), dim=1)
+        logits = self.hidden_to_vocab(combined_features)
+        return logits
+
+# --- C. WordTokenizer (Inchangé) ---
+class WordTokenizer:
+    # ... (code inchangé) ...
+    """Tokenizer Aricate adapté pour recharger à partir du vocabulaire publié."""
+    def __init__(self, word_to_id: dict):
+        self.word_to_id = word_to_id
+        self.id_to_word = {id: word for word, id in word_to_id.items()}
+        self.vocab_size = len(word_to_id)
+        self.special_tokens = {
+            '<pad>': word_to_id['<pad>'],
+            '<unk>': word_to_id['<unk>'],
+            '<eos>': word_to_id['<eos>'],
+            '<sep>': word_to_id['<sep>'],
+        }
+
+    def encode(self, text, add_eos=False):
+        words = text.lower().split()
+        if add_eos:
+            words.append('<eos>')
+        ids = [self.word_to_id.get(word, self.word_to_id['<unk>']) for word in words]
+        return ids
+
+    def decode(self, ids):
+        words = [self.id_to_word.get(id, '<unk>') for id in ids]
+        return " ".join(word for word in words if word not in ['<pad>', '<unk>', '<eos>', '<sep>'])
+
+# --- D. Fonction de Génération (MODIFIÉE pour Top-K Sampling et Temperature) ---
+def generate_sequence(model, tokenizer, question, max_length, max_len_input, temperature=1.0, top_k=None):
+    """
+    Génère la réponse en utilisant Top-K Sampling et Temperature.
+    
+    Args:
+        temperature (float): Ajuste la créativité (T > 1.0) ou la prudence (T < 1.0).
+        top_k (int/None): Limite le choix aux K mots les plus probables pour l'échantillonnage.
+    """
+    model.eval()
+    
+    sep_id = tokenizer.special_tokens['<sep>']
+    eos_id = tokenizer.special_tokens['<eos>']
+
+    question_ids = tokenizer.encode(question)
+    current_sequence = question_ids + [sep_id]
+    
+    print(f"\n--- Q/A Génération (Sampling | T={temperature:.2f} | K={top_k if top_k else 'désactivé'}) ---")
+    print(f"Question: '{question}'")
+
+    with torch.no_grad():
+        for _ in range(max_length):
+            
+            # Préparer l'entrée
+            input_ids_to_pad = current_sequence[-max_len_input:] if len(current_sequence) > max_len_input else current_sequence
+            padding_needed = max_len_input - len(input_ids_to_pad)
+            input_ids_padded = [tokenizer.special_tokens['<pad>']] * padding_needed + input_ids_to_pad
+            input_tensor = torch.tensor(input_ids_padded).unsqueeze(0)
+
+            # 1. Obtention des logits
+            logits = model(input_tensor).squeeze(0)
+
+            # 2. Application de la Temperature
+            if temperature != 1.0 and temperature > 0:
+                logits = logits / temperature
+
+            # 3. Application du Top-K
+            if top_k is not None:
+                # Filtrer les logits pour ne garder que le top_k
+                values, indices = torch.topk(logits, k=top_k)
+                
+                # Créer un masque (tensor rempli de -inf)
+                mask = torch.ones_like(logits) * float('-inf')
+                
+                # Mettre à jour le masque avec les valeurs filtrées
+                logits = torch.scatter(mask, dim=0, index=indices, src=values)
+
+            # 4. Convertir en probabilités et échantillonner
+            probabilities = F.softmax(logits, dim=-1)
+            
+            # S'assurer que les probabilités somment à 1
+            if top_k is not None:
+                probabilities = probabilities.div(probabilities.sum())
+            
+            predicted_id = torch.multinomial(probabilities, num_samples=1).item()
+
+            # 5. Mettre à jour la séquence
+            current_sequence.append(predicted_id)
+
+            if predicted_id == eos_id:
+                break
+
+    # 6. Décodage
+    try:
+        sep_index = current_sequence.index(sep_id)
+        response_ids = [id for id in current_sequence[sep_index+1:] if id != eos_id]
+    except ValueError:
+        response_ids = current_sequence
+
+    final_response = tokenizer.decode(response_ids)
+    
+    # Dans le sampling, on n'a pas de score de log-probabilité unique comme dans Beam Search.
+    print(f"Réponse générée: '{final_response}'")
+    print("-" * 40)
+    
+    return final_response
+
+# --- E. Fonction de Chargement du Modèle Lam-2 (Inchangée) ---
+def load_lam2_model(repo_id: str):
+    # ... (code inchangé) ...
+    """
+    Télécharge et charge le modèle Lam-2 et son tokenizer depuis Hugging Face.
+    """
+    print(f"--- Chargement de Lam-2 depuis {repo_id} ---")
+
+    # 1. Télécharger le tokenizer
+    tokenizer_path = hf_hub_download(repo_id=repo_id, filename="aricate_tokenizer.txt")
+    with open(tokenizer_path, 'r', encoding='utf-8') as f:
+        word_to_id = json.load(f)
+    tokenizer = WordTokenizer(word_to_id)
+    print(f"Tokenizer chargé. Taille du vocabulaire: {tokenizer.vocab_size}")
+
+    # 2. Télécharger la configuration
+    config_path = hf_hub_download(repo_id=repo_id, filename="config.json")
+    with open(config_path, 'r') as f:
+        model_config = json.load(f)
+    print("Configuration du modèle chargée.")
+
+    # 3. Initialiser le modèle
+    model = AricateModel(
+        vocab_size=model_config['vocab_size'],
+        embedding_dim=model_config['embedding_dim'],
+        hidden_dim=model_config['hidden_dim'],
+        config=model_config
+    )
+
+    # 4. Télécharger et charger les poids Safetensors
+    weights_path = hf_hub_download(repo_id=repo_id, filename="model.safetensors")
+    state_dict = load_safetensors_file(weights_path)
+
+    model.load_state_dict(state_dict)
+    print("Poids du modèle Safetensors chargés avec succès.")
+
+    MAX_LEN_INPUT_DEFAULT = 30
+
+    print("-" * 40)
+    return model, tokenizer, MAX_LEN_INPUT_DEFAULT
+
+# --- F. Bloc principal d'exécution (MISE À JOUR) ---
+if __name__ == '__main__':
+
+    LAM2_REPO_ID = "Clemylia/lam-2"
+    MAX_GENERATION_LENGTH = 15
+    
+    # 🚨 NOUVEAUX PARAMÈTRES POUR LE TEST 🚨
+    TEST_TEMPERATURE = 0.9 # > 1.0 pour plus de créativité/aléatoire
+    TEST_TOP_K = 10         # Limite le choix aux 10 mots les plus probables
+
+    test_questions = [
+        "Quel est le pays de la Tour Eiffel ? la France ou le Japon ?",
+        "Qui a écrit \"Le Petit Prince\" ?",
+        "l'élément chimique de l'eau ?",
+        "Notre système solaire compte combien de planètes ?",
+        "L'animal le plus rapide du monde ?",
+    ]
+
+    try:
+        # 1. Chargement du modèle
+        lam2_model, lam2_tokenizer, max_len_input = load_lam2_model(LAM2_REPO_ID)
+
+        print(f"\n>>> TEST D'INFÉRENCE LAM-2 EN MODE CRÉATIF (T={TEST_TEMPERATURE}, K={TEST_TOP_K}) <<<")
+
+        # 2. Infèrence (Appel à la nouvelle fonction)
+        for question in test_questions:
+            generate_sequence( # Remplacement de generate_sequence_beam
+                model=lam2_model,
+                tokenizer=lam2_tokenizer,
+                question=question,
+                max_length=MAX_GENERATION_LENGTH,
+                max_len_input=max_len_input,
+                temperature=TEST_TEMPERATURE,
+                top_k=TEST_TOP_K
+            )
+
+    except Exception as e:
+        print(f"\n❌ Une erreur est survenue lors du chargement ou de l'inférence.")
+        print(f"Détail de l'erreur: {e}")
+        print("Vérifiez l'installation des dépendances et le REPO_ID.")
+```