README.md

---
library_name: transformers
license: apache-2.0
datasets:
- Clemylia/Melta-revive
language:
- fr
pipeline_tag: text-generation
---
# 🚀 Melta-82M : Le LLM Fonctionnel et Efficace

## 💡 Présentation Générale

| Caractéristique | Détail |
| :--- | :--- |
| **Nom du Modèle** | **Melta-82M** (Basé sur le projet Melta-revive) |
| **Créateur** | Clemylia / LES-IA-ETOILES |
| **Architecture** | **Transformer Llama** (Initialisé *from scratch*) |
| **Taille (Paramètres)** | **82 millions** |
| **Objectif** | Servir de modèle de fondation (**LLM Fonctionnel à Faible Paramètre**) pour le *Fine-Tuning* d'assistants spécialisés (comme Malya 🎶 ou Charlotte 💖). |
| **Langue** | Français |

Melta-82M représente la première tentative réussie de Clemylia d'entraîner une architecture Llama *from scratch*. Il est conçu pour prouver que l'efficacité de l'apprentissage des Transformers peut être atteinte avec un nombre de paramètres relativement faible, défiant la nécessité de modèles de plusieurs milliards.

## ⚙️ Détails Techniques de l'Architecture

Melta-82M est basé sur une configuration Llama optimisée pour la vitesse d'entraînement :

| Hyperparamètre | Valeur | Rôle dans l'Efficacité |
| :--- | :--- | :--- |
| **`hidden_size`** | 512 | Définit la dimension cachée du modèle. Gardé faible pour minimiser le coût de calcul. |
| **`num_hidden_layers`** | 12 | Nombre de blocs Transformer. Un bon équilibre pour capturer la complexité du langage sans alourdir le modèle. |
| **`num_attention_heads`**| 12 | Nombre de têtes d'attention. Permet au modèle d'analyser différentes facettes de la séquence simultanément. |
| **`vocab_size`** | \~32 000 | Taille du vocabulaire (ajustée après l'ajout du jeton `[PAD]`). Utilise un *tokenizer* sub-mot standard. |
| **`max_position_embeddings`**| 600 | Longueur maximale des séquences que le modèle peut traiter. |

## 🧪 Statut et Utilisation Actuelle

### 🚧 Statut de l'Entraînement

Melta-82M est actuellement dans une **phase de pré-apprentissage précoce** :

  * **Données d'Entraînement :** Entraîné initialement sur seulement 650 lignes de paires Questions/Réponses (`Clemylia/Melta-revive`).

### 🎯 Prochaine Étape : Le Fine-Tuning

Ce modèle est prêt pour :

1.  **L'augmentation massive du *dataset* :** Il nécessite un entraînement sur des millions de *tokens* pour atteindre une cohérence factuelle et sémantique.
2.  **L'Affinement d'Instruction (Fine-Tuning) :** Une fois la cohérence atteinte, il pourra être affiné
## ⬇️ Comment Utiliser Melta-82M

Vous pouvez charger ce modèle directement via la bibliothèque **Hugging Face Transformers** pour l'inférence :

```python
from transformers import AutoTokenizer, LlamaForCausalLM

# Le modèle Llama 82M est chargé avec ses poids entraînés
model = LlamaForCausalLM.from_pretrained("Clemylia/Melta")
tokenizer = AutoTokenizer.from_pretrained("Clemylia/Melta")
```

**⚠️ Note :** En raison de son statut d'entraînement précoce, les utilisateurs sont invités à effectuer des Fine-Tuning supplémentaires avant toute utilisation en production.

toujours utilisé :
Question: Votre entrée\nRéponse

utilisation :

```
import torch
from transformers import (
    AutoTokenizer,
    LlamaForCausalLM,
)

# --- CONFIGURATION D'INFÉRENCE ---
# Remplacé par le dépôt Hugging Face
MODEL_REPO = "Clemylia/Melta"

def load_model_and_tokenizer(repo_id):
    """Charge le modèle LLaMA entraîné et son Tokenizer depuis Hugging Face."""
    print(f"Chargement du modèle et du tokenizer depuis Hugging Face : {repo_id}...")

    try:
        # 1. Charger le Tokenizer
        tokenizer = AutoTokenizer.from_pretrained(repo_id, trust_remote_code=True)
        # S'assurer que le pad_token_id est correctement défini si le modèle en a besoin
        if tokenizer.pad_token_id is None:
            if tokenizer.pad_token is None:
                 # Le modèle LLaMA entraîné from scratch aura besoin de cette configuration
                 tokenizer.add_special_tokens({'pad_token': '[PAD]'})
            tokenizer.pad_token_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)


        # 2. Charger le Modèle LLaMA
        # LlamaForCausalLM charge le modèle et sa configuration depuis le dépôt HF
        model = LlamaForCausalLM.from_pretrained(repo_id)

    except Exception as e:
        print(f"❌ Erreur lors du chargement depuis Hugging Face. Le dépôt '{repo_id}' existe-t-il ? : {e}")
        return None, None

    return model, tokenizer

def run_inference(model, tokenizer):
    """Effectue l'inférence (génération de texte) avec le modèle chargé."""
    print("\n--- TEST D'INFÉRENCE ---")

    # 0. Vérification de l'environnement
    # Utiliser la carte graphique si elle est disponible
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)
    model.eval()

    # 1. Définir le prompt
    prompt = "Question: Qui est Clem ?\nRéponse:"
    print(f"Prompt d'entrée : {prompt}")

    # 2. Tokenisation
    inputs = tokenizer(prompt, return_tensors="pt").to(device)

    # 3. Génération de la réponse
    with torch.no_grad():
        output_tokens = model.generate(
            **inputs,
            max_length=150,             # Limite de longueur de la réponse
            num_return_sequences=1,
            do_sample=True,
            top_k=50,
            top_p=0.95,
            temperature=0.7,
            pad_token_id=tokenizer.pad_token_id
        )

    # 4. Décodage et affichage
    # skip_special_tokens=False pour voir les balises de fin de séquence (</s>)
    response = tokenizer.decode(output_tokens[0], skip_special_tokens=False)
    print(f"\nRéponse générée :\n{response}")
    print("-------------------------")


# --- EXECUTION PRINCIPALE ---
if __name__ == "__main__":
    model, tokenizer = load_model_and_tokenizer(MODEL_REPO)

    if model and tokenizer:
        run_inference(model, tokenizer)
        print("\n✅ Test d'inférence terminé.")
    else:
        print("\n❌ Impossible de lancer l'inférence. Vérifiez le nom du dépôt Hugging Face.")
```