Clemylia / Melta

🚀 Melta-82M : Le LLM Fonctionnel et Efficace

💡 Présentation Générale

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 :

🧪 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 ).
• Résultats : Le modèle a réussi à apprendre la structure de dialogue ( Question: / Réponse: ) et les éléments d'identité ( Melta27 , Clem27 ). Cependant, il souffre encore d'une forte incohérence sémantique et génère des néologismes et des caractères aléatoires, car les 82 millions de paramètres n'ont pas encore été stabilisés par un volume suffisant de données.

🎯 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é (comme vous l'avez fait pour Charlotte) pour devenir des assistants spécialisés de Classe 5 .

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