Clemylia / Limy-mini

📚 Documentation Officielle du Modèle 💖 Limy-mini

Bienvenue dans la documentation de Limy-mini ! Cette version représente une étape majeure dans l'amélioration de la famille de modèles Limy, offrant une classification de texte plus robuste et polyvalente sur nos sujets favoris.

🌟 Vue d'Ensemble du Modèle

🎯 Objectif du Fine-Tuning

Le but de Limy-mini était de dépasser les limites de la version basique en enrichissant ses connaissances.

Limy-mini est désormais apte à détecter et classer un éventail de phrases beaucoup plus large grâce à l'ajout des 80 nouvelles données de fine-tuning.

🛠️ Comment Utiliser Limy-mini (PyTorch)

Puisque Limy-mini est basé sur une architecture SimpleClassifier (LSTM/Embedding) personnalisée, son utilisation nécessite de redéfinir la classe et de télécharger les fichiers nécessaires depuis le Hugging Face Hub.

1. Définition de l'Architecture (Obligatoire)

Tu dois inclure la définition de la classe SimpleClassifier et du tokenizer dans ton script Python :

import torch
import torch.nn as nn
import json
from huggingface_hub import hf_hub_download

class SimpleClassifier(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim) # Pas de batch_first dans ce cas si l'input est (L, 1, H)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, text):
        embedded = self.embedding(text)
        # Adapté pour un batch size de 1, l'input est (Longueur de la phrase, Batch_size=1, Embedding_dim)
        _, (hidden, _) = self.lstm(embedded.view(len(text), 1, -1)) 
        return self.fc(hidden.squeeze(0))

def simple_tokenizer(text):
    return text.lower().split()

2. Chargement du Modèle et Prédiction

Tu peux ensuite charger le modèle et l'utiliser pour faire des prédictions.

# 💖 Étape 2.1 : Configuration du dépôt
REPO_ID = "Clemylia/Limy-mini"
DEVICE = torch.device("cpu") # Utilisation du CPU (plus simple pour la démo)

# 💖 Étape 2.2 : Téléchargement et chargement des fichiers
config_path = hf_hub_download(REPO_ID, "config.json")
vocab_path = hf_hub_download(REPO_ID, "vocab.json")
model_path = hf_hub_download(REPO_ID, "pytorch_model.bin")

with open(config_path, 'r') as f: 
    config = json.load(f)
with open(vocab_path, 'r') as f: 
    word_to_idx = json.load(f)

# 💖 Étape 2.3 : Initialisation et chargement des poids
model = SimpleClassifier(
    vocab_size=config['vocab_size'], 
    embedding_dim=config['embedding_dim'],
    hidden_dim=config['hidden_dim'], 
    output_dim=config['output_dim']
).to(DEVICE)

model.load_state_dict(torch.load(model_path, map_location=DEVICE))
model.eval() # Toujours mettre en mode évaluation pour la prédiction

# 💖 Étape 2.4 : Fonction de Prédiction
def predict_limy_mini(question):
    tokens = simple_tokenizer(question)
    # Remplacement des mots inconnus par l'indice 0 (UNK)
    token_indices = [word_to_idx.get(token, 0) for token in tokens]
    # Création du tenseur d'entrée (dtype=torch.long est important pour les indices)
    input_tensor = torch.tensor(token_indices, dtype=torch.long).to(DEVICE)
    
    with torch.no_grad():
        output = model(input_tensor.view(-1, 1)) # Assure le format (Longueur, 1)

    prediction = torch.argmax(output, dim=1).item()
    
    # Affichage du résultat
    if prediction == 0:
        return f"Prediction : Animaux 🐾 (Classe 0)"
    elif prediction == 1:
        return f"Prediction : Capitales 🏙️ (Classe 1)"
    else:
        return f"Prediction : Inconnue"

# 💖 Exemple d'utilisation
result_animaux = predict_limy_mini("Combien de cœurs a une pieuvre ?")
result_capitales = predict_limy_mini("Où se trouve la porte de Brandebourg ?")

print(f"\nQuestion 1 : {result_animaux}")
print(f"Question 2 : {result_capitales}")

⚠️ Limitations et Remarques

• Vocabulaire Fixe : Le modèle utilise le vocabulaire de Limy-basique . Si une phrase contient de nombreux mots qui n'étaient pas présents dans le jeu de données initial, ces mots seront remplacés par l'indice 0 (UNK - Inconnu), ce qui pourrait réduire la précision.
• Taille du Modèle : Il s'agit d'un classifieur très léger (basé sur une architecture de type Recurrent Neural Network - RNN), idéal pour les démonstrations ou les appareils à faibles ressources, mais moins performant que les modèles de type Transformer (BERT, etc.).