Upload folder using huggingface_hub

README.md

@@ -0,0 +1,138 @@
+---
+language:
+- fr
+license: apache-2.0
+tags:
+- causal-lm
+- french
+- minigpt
+- text-generation
+- transformers
+- pytorch
+pipeline_tag: text-generation
+---
+
+# MiniGPT-FR
+
+MiniGPT-FR est un modèle de langage causal entraîné pour la génération de texte en français.  
+Il s’agit d’un modèle de type decoder-only Transformer, conçu pour apprendre la structure de la langue française et générer des textes cohérents à partir d’un prompt.
+
+Le modèle a été entraîné progressivement sur des corpus textuels français, avec une montée en taille du dataset afin de stabiliser l’apprentissage linguistique.
+
+---
+
+## Architecture
+
+Type : Causal Language Model (decoder-only)  
+Architecture : Transformer  
+Position encoding : RoPE  
+Activation FFN : SwiGLU  
+Weight sharing : FFN sharing  
+Nombre de paramètres : ~60M  
+Contexte maximal : 256 tokens  
+
+Configuration principale :
+- Layers : 20
+- Hidden size : 640
+- Attention heads : 10
+- FFN hidden size : 2560
+- Dropout : 0.15
+
+---
+
+## Entraînement
+
+- Entraînement en next-token prediction
+- Curriculum learning avec augmentation progressive du dataset
+- Dataset final : 200k entrées
+- Langue : français
+- Optimiseur : AdamW
+- Scheduler : Cosine decay avec warmup
+- Validation suivie via la cross-entropy loss
+
+Ce modèle n’est pas instruction-tuned.  
+Il est optimisé pour la complétion de texte et la génération libre.
+
+---
+
+## Capacités
+
+- Génération de texte en français
+- Complétion de phrases
+- Reformulation simple
+- Génération de paragraphes descriptifs
+- Style encyclopédique et informatif dominant
+
+Limitations connues :
+- Pas d’alignement instructionnel
+- Peut halluciner des faits
+- Pas optimisé pour le raisonnement complexe
+- Contexte limité à 256 tokens
+
+---
+
+## Utilisation avec Transformers
+
+Exemple minimal en PyTorch :
+
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+model_name = "Houzeric/MiniGPT-FR"
+
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(
+    model_name,
+    trust_remote_code=True
+)
+
+prompt = "Il est principalement connu pour"
+inputs = tokenizer(prompt, return_tensors="pt")
+
+outputs = model.generate(
+    **inputs,
+    max_new_tokens=100,
+    temperature=0.8,
+    top_p=0.95,
+    do_sample=True
+)
+
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
+
+---
+
+## Tokenizer
+
+Tokenizer utilisé : camembert-base  
+Vocabulaire partagé  
+Padding aligné sur le token EOS
+
+---
+
+## Fichiers du dépôt
+
+- pytorch_model.bin : poids du modèle
+- config.json : configuration du modèle
+- tokenizer.json
+- tokenizer_config.json
+- special_tokens_map.json
+- fichiers modeling et configuration chargés via trust_remote_code
+
+---
+
+## Licence
+
+Ce modèle est distribué sous licence Apache 2.0.
+
+---
+
+## Avertissement
+
+Ce modèle est fourni à des fins de recherche et d’expérimentation.  
+Les textes générés peuvent être inexacts, incomplets ou incohérents.  
+Aucune garantie n’est fournie quant à l’exactitude des informations produites.
+
+---
+
+## Crédits
+
+Modèle développé et entraîné indépendamment dans un cadre expérimental, avec un focus sur l’apprentissage progressif du français et l’optimisation de modèles de taille intermédiaire.

config.json

@@ -0,0 +1,25 @@
+{
+  "model_type": "minigpt",
+  "architectures": [
+    "MiniGPTForCausalLM"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration.MiniGPTConfig",
+    "AutoModelForCausalLM": "modeling_minigpt.MiniGPTForCausalLM"
+  },
+  "tokenizer_class": "CamembertTokenizer",
+  "tokenizer_name": "camembert-base",
+  "vocab_size": 32005,
+  "pad_token_id": 1,
+  "bos_token_id": 0,
+  "eos_token_id": 2,
+  "embed_dim": 640,
+  "depth": 20,
+  "heads": 10,
+  "hidden_dim": 2560,
+  "block_size": 256,
+  "dropout": 0.1,
+  "use_rope": true,
+  "weight_sharing": "ffn",
+  "tie_word_embeddings": false
+}

configuration.py

@@ -0,0 +1,38 @@
+from transformers import PretrainedConfig
+
+
+class MiniGPTConfig(PretrainedConfig):
+    """
+    Configuration pour le modèle MiniGPT.
+    
+    Cette classe hérite de PretrainedConfig pour être compatible avec
+    l'écosystème Hugging Face.
+    """
+    model_type = "minigpt"
+    
+    def __init__(
+        self,
+        vocab_size=32000,
+        block_size=256,
+        embed_dim=256,
+        depth=8,
+        heads=8,
+        dropout=0.1,
+        hidden_dim=512,
+        weight_sharing="none",
+        use_rope=True,
+        use_gradient_checkpointing=False,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.vocab_size = vocab_size
+        self.block_size = block_size
+        self.embed_dim = embed_dim
+        self.depth = depth
+        self.heads = heads
+        self.dropout = dropout
+        self.hidden_dim = hidden_dim
+        self.weight_sharing = weight_sharing
+        self.use_rope = use_rope
+        self.use_gradient_checkpointing = use_gradient_checkpointing
+

model.py

@@ -0,0 +1,346 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
+from transformers import PreTrainedModel
+from .configuration import MiniGPTConfig
+
+
+class RoPEEmbedding(nn.Module):
+    """Rotary Position Embedding (RoPE) comme utilisé dans LLaMA et autres LLMs modernes.
+    
+    RoPE encode les positions directement dans les queries et keys via des rotations,
+    sans nécessiter de paramètres apprenables.
+    
+    Args:
+        dim: Dimension de chaque tête d'attention (embed_dim // num_heads)
+        max_seq_len: Longueur de séquence maximale
+        base: Base pour le calcul des fréquences (10000 par défaut)
+    """
+    def __init__(self, dim, max_seq_len=2048, base=10000):
+        super().__init__()
+        self.dim = dim
+        self.max_seq_len = max_seq_len
+        self.base = base
+        
+        # Précalculer les fréquences
+        inv_freq = 1.0 / (base ** (torch.arange(0, dim, 2).float() / dim))
+        self.register_buffer("inv_freq", inv_freq)
+        
+        # Précalculer cos et sin pour toutes les positions
+        t = torch.arange(max_seq_len).type_as(self.inv_freq)
+        freqs = torch.einsum("i,j->ij", t, self.inv_freq)
+        emb = torch.cat((freqs, freqs), dim=-1)
+        self.register_buffer("cos_cached", emb.cos()[None, None, :, :])
+        self.register_buffer("sin_cached", emb.sin()[None, None, :, :])
+    
+    def rotate_half(self, x):
+        """Rotation de moitié des dimensions."""
+        x1, x2 = x[..., :x.shape[-1]//2], x[..., x.shape[-1]//2:]
+        return torch.cat((-x2, x1), dim=-1)
+    
+    def forward(self, q, k):
+        """Applique RoPE aux queries et keys.
+        
+        Args:
+            q: queries [batch, heads, seq_len, head_dim]
+            k: keys [batch, heads, seq_len, head_dim]
+        
+        Returns:
+            q_rot, k_rot: queries et keys avec positions encodées
+        """
+        seq_len = q.shape[2]
+        
+        # Tronquer les embeddings si la séquence est plus courte
+        cos = self.cos_cached[:, :, :seq_len, :]
+        sin = self.sin_cached[:, :, :seq_len, :]
+        
+        # Appliquer la rotation
+        q_rot = (q * cos) + (self.rotate_half(q) * sin)
+        k_rot = (k * cos) + (self.rotate_half(k) * sin)
+        
+        return q_rot, k_rot
+
+
+class SwiGLU(nn.Module):
+    """SwiGLU activation function as described in the Super Tiny LM paper.
+    SwiGLU(x) = (Swish(xW) ⊗ xV)W2
+    where Swish(x) = SiLU(x) in PyTorch
+    """
+    def __init__(self, embed_dim, hidden_dim):
+        super().__init__()
+        self.w = nn.Linear(embed_dim, hidden_dim, bias=False)
+        self.v = nn.Linear(embed_dim, hidden_dim, bias=False)
+        self.w2 = nn.Linear(hidden_dim, embed_dim, bias=False)
+    
+    def forward(self, x):
+        return self.w2(F.silu(self.w(x)) * self.v(x))
+
+
+class SelfAttention(nn.Module):
+    def __init__(self, embed_dim, heads, dropout, max_seq_len=2048, use_rope=True):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.heads = heads
+        self.head_dim = embed_dim // heads
+        self.use_rope = use_rope
+        
+        self.q_proj = nn.Linear(embed_dim, embed_dim)
+        self.k_proj = nn.Linear(embed_dim, embed_dim)
+        self.v_proj = nn.Linear(embed_dim, embed_dim)
+        self.out = nn.Linear(embed_dim, embed_dim)
+        self.attn_dropout = dropout 
+        self.resid_dropout = nn.Dropout(dropout)
+        
+        # RoPE embeddings (pas de paramètres apprenables)
+        if use_rope:
+            self.rope = RoPEEmbedding(self.head_dim, max_seq_len=max_seq_len)
+
+    def forward(self, x, mask=None):
+        B, T, C = x.size()
+        q = self.q_proj(x).reshape(B, T, self.heads, self.head_dim).transpose(1, 2)
+        k = self.k_proj(x).reshape(B, T, self.heads, self.head_dim).transpose(1, 2)
+        v = self.v_proj(x).reshape(B, T, self.heads, self.head_dim).transpose(1, 2)
+        
+        # Appliquer RoPE aux queries et keys si activé
+        if self.use_rope:
+            q, k = self.rope(q, k)
+
+        attn = F.scaled_dot_product_attention(
+            q, k, v,
+            attn_mask=None,
+            is_causal=True,
+            dropout_p=self.attn_dropout if self.training else 0.0,
+        )
+        attn = attn.transpose(1, 2).contiguous().view(B, T, C)
+        return self.resid_dropout(self.out(attn))
+
+class TransformerBlock(nn.Module):
+    def __init__(self, embed_dim, heads, dropout=0.1, hidden_dim = 512, layerdrop=0.1, shared_ff=None, max_seq_len=2048, use_rope=True):
+        super().__init__()
+        self.attn = SelfAttention(embed_dim, heads, dropout, max_seq_len=max_seq_len, use_rope=use_rope)
+        self.ln1 = nn.LayerNorm(embed_dim)
+        # Utiliser un FFN partagé si fourni, sinon créer un nouveau
+        self.ff = shared_ff if shared_ff is not None else SwiGLU(embed_dim, hidden_dim)
+        self.ln2 = nn.LayerNorm(embed_dim)
+        self.dropout = nn.Dropout(dropout)
+        self.layerdrop = layerdrop
+
+    def forward(self, x, mask=None):
+        if self.training and torch.rand(1).item() < self.layerdrop:
+            return x
+        x = x + self.dropout(self.attn(self.ln1(x), mask))
+        x = x + self.dropout(self.ff(self.ln2(x)))
+        return x
+    
+    def forward_checkpointed(self, x, mask=None):
+        """Version avec gradient checkpointing pour économiser VRAM."""
+        return self.forward(x, mask)
+
+class MiniGPT(PreTrainedModel):
+    config_class = MiniGPTConfig
+    
+    def __init__(self, config=None, **kwargs):
+        """
+        Initialise le modèle MiniGPT.
+        
+        Args:
+            config: Instance de MiniGPTConfig ou None. Si None, les paramètres
+                   doivent être fournis via kwargs.
+            **kwargs: Paramètres du modèle si config n'est pas fourni.
+        """
+        # Si config n'est pas fourni, créer une config à partir des kwargs
+        if config is None:
+            config = MiniGPTConfig(**kwargs)
+        
+        super().__init__(config)
+        
+        # Extraire les paramètres de la config
+        vocab_size = config.vocab_size
+        block_size = config.block_size
+        embed_dim = config.embed_dim
+        depth = config.depth
+        heads = config.heads
+        dropout = config.dropout
+        hidden_dim = config.hidden_dim
+        weight_sharing = config.weight_sharing
+        use_rope = config.use_rope
+        use_gradient_checkpointing = config.use_gradient_checkpointing
+        self.token_emb = nn.Embedding(vocab_size, embed_dim)
+        self.use_rope = use_rope
+        self.use_gradient_checkpointing = use_gradient_checkpointing
+        
+        # Positional embeddings uniquement si on n'utilise pas RoPE
+        if not use_rope:
+            self.pos_emb = nn.Embedding(block_size, embed_dim)
+        else:
+            self.pos_emb = None
+        
+        self.depth = depth
+        self.weight_sharing = weight_sharing
+        self.vocab_size = vocab_size
+        self.block_size = block_size
+        self.embed_dim = embed_dim
+        self.heads = heads
+        self.hidden_dim = hidden_dim
+        
+        # Créer les blocs selon le type de weight sharing
+        if weight_sharing == "none":
+            # Comportement original : chaque bloc a ses propres poids
+            self.blocks = nn.ModuleList([
+                TransformerBlock(embed_dim, heads, dropout, hidden_dim, layerdrop=0.1, 
+                               max_seq_len=block_size, use_rope=use_rope) 
+                for _ in range(depth)
+            ])
+        elif weight_sharing == "ffn":
+            # Partage uniquement les FFN, attention séparée
+            shared_ff = SwiGLU(embed_dim, hidden_dim)
+            self.blocks = nn.ModuleList([
+                TransformerBlock(embed_dim, heads, dropout, hidden_dim, layerdrop=0.1, 
+                               shared_ff=shared_ff, max_seq_len=block_size, use_rope=use_rope)
+                for _ in range(depth)
+            ])
+        elif weight_sharing == "full":
+            # ALBERT-style : un seul bloc réutilisé depth fois
+            self.shared_block = TransformerBlock(embed_dim, heads, dropout, hidden_dim, layerdrop=0.1,
+                                                max_seq_len=block_size, use_rope=use_rope)
+            self.blocks = None  # On n'utilise pas de ModuleList dans ce cas
+        else:
+            raise ValueError(f"weight_sharing doit être 'none', 'ffn' ou 'full', pas '{weight_sharing}'")
+        
+        self.ln_f = nn.LayerNorm(embed_dim)
+        self.head = nn.Linear(embed_dim, vocab_size, bias=False) # on enleve bias pour que head et token_emb est la meme taille
+        self.head.weight = self.token_emb.weight #On réutilise les poids de la matrice token_emb pour les tetes 
+        self.block_size = block_size
+        self.apply(self._init_weights)
+
+    def forward(self, idx):
+        B, T = idx.shape
+        
+        # Token embeddings
+        x = self.token_emb(idx)
+        
+        # Ajouter positional embeddings uniquement si on n'utilise pas RoPE
+        if not self.use_rope:
+            pos = torch.arange(0, T, device=idx.device).unsqueeze(0)
+            x = x + self.pos_emb(pos)
+
+        mask = torch.tril(torch.ones(T, T, device=idx.device)).unsqueeze(0).unsqueeze(0)
+        
+        # Gradient checkpointing : économise VRAM en recalculant les activations
+        if self.use_gradient_checkpointing and self.training:
+            if self.weight_sharing == "full":
+                for _ in range(self.depth):
+                    x = checkpoint(self.shared_block.forward_checkpointed, x, mask, use_reentrant=False)
+            else:
+                for block in self.blocks:
+                    x = checkpoint(block.forward_checkpointed, x, mask, use_reentrant=False)
+        else:
+            # Mode normal (pas de checkpointing)
+            if self.weight_sharing == "full":
+                for _ in range(self.depth):
+                    x = self.shared_block(x, mask)
+            else:
+                for block in self.blocks:
+                    x = block(x, mask)
+
+        x = self.ln_f(x)
+        return self.head(x)
+    
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                torch.nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+        elif isinstance(module, nn.LayerNorm):
+            torch.nn.init.ones_(module.weight)
+            torch.nn.init.zeros_(module.bias)
+            
+            
+    def count_parameters(self):
+        """Compte le nombre de paramètres selon le type de weight sharing et use_rope."""
+        total = sum(p.numel() for p in self.parameters())
+        trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
+        
+        # Détails par composant
+        token_emb_params = self.token_emb.weight.numel()
+        pos_emb_params = self.pos_emb.weight.numel() if self.pos_emb is not None else 0
+        embedding_params = token_emb_params + pos_emb_params
+        
+        if self.weight_sharing == "full":
+            block_params = sum(p.numel() for p in self.shared_block.parameters())
+        else:
+            block_params = sum(p.numel() for p in self.blocks.parameters())
+        
+        return {
+            "total": total,
+            "trainable": trainable,
+            "embedding": embedding_params,
+            "token_emb": token_emb_params,
+            "pos_emb": pos_emb_params,
+            "blocks": block_params,
+            "head": 0,  # Head partage les poids avec embedding
+            "weight_sharing": self.weight_sharing,
+            "use_rope": self.use_rope
+        }
+    
+    @torch.no_grad()
+    def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None, top_p=None, min_new_tokens=0, eos_token_id=None):
+        """
+        Génération de texte avec contrôle de la diversité.
+        
+        Args:
+            idx: Context initial [batch, seq_len]
+            max_new_tokens: Nombre de tokens à générer
+            temperature: Contrôle la diversité (0.1=conservateur, 1.0=normal, 2.0=créatif)
+            top_k: Garde seulement les k tokens les plus probables
+            top_p: Nucleus sampling, garde les tokens dont la somme des probas = p
+            min_new_tokens: Génère au moins ce nombre de tokens avant d'autoriser l'arrêt sur eos_token_id
+            eos_token_id: Id du token EOS pour stopper la génération (optionnel)
+        """
+        for step in range(max_new_tokens):
+            idx_cond = idx[:, -self.block_size:]
+            logits = self(idx_cond)
+            logits = logits[:, -1, :]
+            
+            # Appliquer la température
+            if temperature != 1.0:
+                logits = logits / temperature
+            
+            # Top-k filtering
+            if top_k is not None:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = -float('Inf')
+            
+            # Top-p (nucleus) filtering
+            if top_p is not None:
+                sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+                
+                # Retirer les tokens au-delà du seuil top_p
+                sorted_indices_to_remove = cumulative_probs > top_p
+                # Garder au moins le premier token
+                sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+                sorted_indices_to_remove[..., 0] = 0
+                
+                # Scatter les valeurs -inf
+                indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)
+                logits[indices_to_remove] = -float('Inf')
+            
+            # Échantillonner
+            probs = F.softmax(logits, dim=-1)
+            next_token = torch.multinomial(probs, num_samples=1)
+
+            # Éviter un EOS trop tôt
+            if eos_token_id is not None and step < min_new_tokens:
+                while next_token.item() == eos_token_id:
+                    next_token = torch.multinomial(probs, num_samples=1)
+
+            idx = torch.cat((idx, next_token), dim=1)
+
+            # Arrêt précoce si EOS après le minimum requis
+            if eos_token_id is not None and step >= min_new_tokens and next_token.item() == eos_token_id:
+                break
+        return idx

modeling_minigpt.py

@@ -0,0 +1,209 @@
+"""
+Modèle MiniGPT pour Hugging Face Transformers.
+
+Ce fichier contient MiniGPTForCausalLM qui est la classe standard
+attendue par Hugging Face pour les modèles de génération de texte.
+
+MiniGPTForCausalLM hérite de MiniGPTModel et ajoute uniquement la tête de langage.
+"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import CausalLMOutputWithPast
+from .configuration import MiniGPTConfig
+from .modeling_minigpt_core import MiniGPTModel
+
+
+
+class MiniGPTForCausalLM(PreTrainedModel):
+    """
+    MiniGPT model avec une tête de langage pour la génération de texte.
+    
+    Cette classe est compatible avec l'écosystème Hugging Face et peut être
+    utilisée avec AutoModelForCausalLM une fois enregistrée.
+    
+    Elle contient :
+    - L'enrobage Hugging Face (méthodes standard)
+    - La logique LM (tête de prédiction)
+    - L'appel au modèle interne (MiniGPTModel)
+    """
+    config_class = MiniGPTConfig
+    base_model_prefix = "model"
+    
+    def __init__(self, config):
+        super().__init__(config)
+        
+        # Modèle core (architecture sans la tête)
+        self.model = MiniGPTModel(config)
+        
+        # Tête de langage (prédiction de tokens)
+        self.lm_head = nn.Linear(config.embed_dim, config.vocab_size, bias=False)
+        
+        # Weight tying : partager les poids entre token_emb et lm_head
+        self.lm_head.weight = self.model.token_emb.weight
+        
+        # Post-initialisation
+        self.post_init()
+
+    def get_input_embeddings(self):
+        """Retourne les embeddings d'entrée."""
+        return self.model.get_input_embeddings()
+
+    def set_input_embeddings(self, value):
+        """Définit les embeddings d'entrée."""
+        self.model.set_input_embeddings(value)
+        # Mettre à jour le weight tying
+        self.lm_head.weight = self.model.token_emb.weight
+
+    def get_output_embeddings(self):
+        """Retourne la tête de sortie."""
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings):
+        """Définit la tête de sortie."""
+        self.lm_head = new_embeddings
+        # Mettre à jour le weight tying
+        self.lm_head.weight = self.model.token_emb.weight
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        labels=None,
+        past_key_values=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs
+    ):
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if input_ids is None:
+            raise ValueError("input_ids doit être fourni")
+
+        # Appel au modèle core
+        outputs = self.model(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        # Extraire les hidden states selon le format de retour
+        if return_dict:
+            hidden_states = outputs.last_hidden_state
+        else:
+            hidden_states = outputs[0]
+
+        # Appliquer la tête de langage
+        logits = self.lm_head(hidden_states)
+
+        # Calculer la loss si labels fournis
+        loss = None
+        if labels is not None:
+            # Shift logits et labels pour l'alignement (prédire le token suivant)
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            loss_fct = nn.CrossEntropyLoss()
+            loss = loss_fct(
+                shift_logits.view(-1, shift_logits.size(-1)),
+                shift_labels.view(-1)
+            )
+
+        # Format de sortie selon return_dict
+        if not return_dict:
+            output = (logits,)
+            if loss is not None:
+                return (loss,) + output
+            return output
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+        )
+
+    
+    def prepare_inputs_for_generation(self, input_ids, past_key_values=None, **kwargs):
+        """Prépare les inputs pour la génération."""
+        # Pour l'instant, on ne supporte pas le past_key_values
+        # Mais on garde la structure pour compatibilité future
+        return {"input_ids": input_ids}
+    
+    @torch.no_grad()
+    def generate(self, input_ids=None, max_new_tokens=100, temperature=1.0, top_k=None, top_p=None, 
+                 min_new_tokens=0, eos_token_id=None, **kwargs):
+        """
+        Génération de texte avec contrôle de la diversité.
+        
+        Args:
+            input_ids: Context initial [batch, seq_len]
+            max_new_tokens: Nombre de tokens à générer
+            temperature: Contrôle la diversité (0.1=conservateur, 1.0=normal, 2.0=créatif)
+            top_k: Garde seulement les k tokens les plus probables
+            top_p: Nucleus sampling, garde les tokens dont la somme des probas = p
+            min_new_tokens: Génère au moins ce nombre de tokens avant d'autoriser l'arrêt sur eos_token_id
+            eos_token_id: Id du token EOS pour stopper la génération (optionnel)
+        """
+        if input_ids is None:
+            raise ValueError("input_ids doit être fourni")
+        
+        idx = input_ids
+        block_size = self.config.block_size
+        
+        for step in range(max_new_tokens):
+            idx_cond = idx[:, -block_size:]
+            logits = self.forward(idx_cond).logits
+            logits = logits[:, -1, :]
+            
+            # Appliquer la température
+            if temperature != 1.0:
+                logits = logits / temperature
+            
+            # Top-k filtering
+            if top_k is not None:
+                v, _ = torch.topk(logits, min(top_k, logits.size(-1)))
+                logits[logits < v[:, [-1]]] = -float('Inf')
+            
+            # Top-p (nucleus) filtering
+            if top_p is not None:
+                sorted_logits, sorted_indices = torch.sort(logits, descending=True)
+                cumulative_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
+                
+                # Retirer les tokens au-delà du seuil top_p
+                sorted_indices_to_remove = cumulative_probs > top_p
+                # Garder au moins le premier token
+                sorted_indices_to_remove[..., 1:] = sorted_indices_to_remove[..., :-1].clone()
+                sorted_indices_to_remove[..., 0] = 0
+                
+                # Scatter les valeurs -inf
+                indices_to_remove = sorted_indices_to_remove.scatter(1, sorted_indices, sorted_indices_to_remove)
+                logits[indices_to_remove] = -float('Inf')
+            
+            # Échantillonner
+            probs = F.softmax(logits, dim=-1)
+            next_token = torch.multinomial(probs, num_samples=1)
+
+            # Éviter un EOS trop tôt
+            if eos_token_id is not None and step < min_new_tokens:
+                while next_token.item() == eos_token_id:
+                    next_token = torch.multinomial(probs, num_samples=1)
+
+            idx = torch.cat((idx, next_token), dim=1)
+
+            # Arrêt précoce si EOS après le minimum requis
+            if eos_token_id is not None and step >= min_new_tokens and next_token.item() == eos_token_id:
+                break
+        
+        return idx
+    
+    def count_parameters(self):
+        """Délègue au modèle core MiniGPTModel."""
+        return self.model.count_parameters()

modeling_minigpt_core.py

@@ -0,0 +1,176 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
+from transformers.modeling_outputs import BaseModelOutputWithPast
+
+from .model import RoPEEmbedding, SwiGLU, SelfAttention, TransformerBlock
+
+from .configuration import MiniGPTConfig
+
+
+class MiniGPTModel(nn.Module):
+    """
+    Modèle core MiniGPT — sans tête LM, pure architecture Transformer.
+    NE DOIT PAS hériter de PreTrainedModel.
+    """
+
+    def __init__(self, config: MiniGPTConfig):
+        super().__init__()
+
+        vocab_size = config.vocab_size
+        block_size = config.block_size
+        embed_dim = config.embed_dim
+        depth = config.depth
+        heads = config.heads
+        dropout = config.dropout
+        hidden_dim = config.hidden_dim
+
+        self.token_emb = nn.Embedding(vocab_size, embed_dim)
+        self.use_rope = config.use_rope
+        self.use_gradient_checkpointing = config.use_gradient_checkpointing
+        self.block_size = block_size
+        self.depth = depth
+        self.weight_sharing = config.weight_sharing
+
+        # Positional embeddings only if not using RoPE
+        if not config.use_rope:
+            self.pos_emb = nn.Embedding(block_size, embed_dim)
+        else:
+            self.pos_emb = None
+
+        # Blocks
+        if self.weight_sharing == "none":
+            self.blocks = nn.ModuleList([
+                TransformerBlock(embed_dim, heads, dropout, hidden_dim,
+                                 max_seq_len=block_size, use_rope=config.use_rope)
+                for _ in range(depth)
+            ])
+
+        elif self.weight_sharing == "ffn":
+            shared_ff = SwiGLU(embed_dim, hidden_dim)
+            self.blocks = nn.ModuleList([
+                TransformerBlock(embed_dim, heads, dropout, hidden_dim,
+                                 shared_ff=shared_ff, max_seq_len=block_size,
+                                 use_rope=config.use_rope)
+                for _ in range(depth)
+            ])
+
+        elif self.weight_sharing == "full":
+            self.shared_block = TransformerBlock(embed_dim, heads, dropout, hidden_dim,
+                                                 max_seq_len=block_size, use_rope=config.use_rope)
+            self.blocks = None
+
+        self.ln_f = nn.LayerNorm(embed_dim)
+        
+    def get_input_embeddings(self):
+        return self.token_emb
+
+    def set_input_embeddings(self, value):
+        self.token_emb = value
+        
+    def get_output_embeddings(self):
+        return None
+
+    def forward(
+        self,
+        input_ids=None,
+        attention_mask=None,
+        past_key_values=None,
+        use_cache=None,
+        output_attentions=None,
+        output_hidden_states=None,
+        return_dict=None,
+        **kwargs
+    ):
+        """
+        Forward pass du modèle core.
+        
+        Args:
+            input_ids: Tokens d'entrée [batch_size, seq_len]
+            attention_mask: Masque d'attention (non utilisé pour l'instant)
+            past_key_values: Cache KV pour génération (non supporté pour l'instant)
+            use_cache: Si True, retourne past_key_values (non supporté pour l'instant)
+            output_attentions: Si True, retourne les attentions (non supporté pour l'instant)
+            output_hidden_states: Si True, retourne tous les hidden states (non supporté pour l'instant)
+            return_dict: Si True, retourne un BaseModelOutputWithPast, sinon un tuple
+        
+        Returns:
+            BaseModelOutputWithPast si return_dict=True, sinon tuple (hidden_states,)
+        """
+        return_dict = return_dict if return_dict is not None else True
+        
+        # Pour l'instant, on ignore ces paramètres (non supportés pour l'instant)
+        # On les ignore silencieusement pour la compatibilité avec l'écosystème Hugging Face
+        if past_key_values is not None:
+            # TODO: Implémenter le support de past_key_values pour la génération efficace
+            pass
+        if output_attentions:
+            # TODO: Implémenter le retour des attentions
+            pass
+        if output_hidden_states:
+            # TODO: Implémenter le retour de tous les hidden states
+            pass
+        
+        B, T = input_ids.shape
+        x = self.token_emb(input_ids)
+
+        if self.pos_emb is not None:  # not using RoPE
+            pos = torch.arange(T, device=input_ids.device).unsqueeze(0)
+            x = x + self.pos_emb(pos)
+
+        mask = torch.tril(torch.ones(T, T, device=input_ids.device)).unsqueeze(0).unsqueeze(0)
+
+        if self.use_gradient_checkpointing and self.training:
+            if self.weight_sharing == "full":
+                for _ in range(self.depth):
+                    x = checkpoint(self.shared_block.forward_checkpointed, x, mask, use_reentrant=False)
+            else:
+                for block in self.blocks:
+                    x = checkpoint(block.forward_checkpointed, x, mask, use_reentrant=False)
+        else:
+            if self.weight_sharing == "full":
+                for _ in range(self.depth):
+                    x = self.shared_block(x, mask)
+            else:
+                for block in self.blocks:
+                    x = block(x, mask)
+
+        hidden_states = self.ln_f(x)
+        
+        if not return_dict:
+            return (hidden_states,)
+        
+        return BaseModelOutputWithPast(
+            last_hidden_state=hidden_states,
+            past_key_values=None,
+            hidden_states=None,
+            attentions=None,
+        )
+    
+    def count_parameters(self):
+        """Compte le nombre de paramètres selon le type de weight sharing et l’utilisation de RoPE."""
+        total = sum(p.numel() for p in self.parameters())
+        trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
+
+        token_emb_params = self.token_emb.weight.numel()
+        pos_emb_params = self.pos_emb.weight.numel() if self.pos_emb is not None else 0
+        embedding_params = token_emb_params + pos_emb_params
+
+        if self.weight_sharing == "full":
+            block_params = sum(p.numel() for p in self.shared_block.parameters())
+        else:
+            block_params = sum(p.numel() for p in self.blocks.parameters())
+
+        return {
+            "total": total,
+            "trainable": trainable,
+            "embedding": embedding_params,
+            "token_emb": token_emb_params,
+            "pos_emb": pos_emb_params,
+            "blocks": block_params,
+            "head": 0,
+            "weight_sharing": self.weight_sharing,
+            "use_rope": self.use_rope
+        }
+

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:511713ff23bba51a7cf5dfff7e05724c0b893852406b49281a1ae981cc173283
+size 235821291