🚀 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 :

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.")