Clemylia / Limy-basique

Limy-basique 🚀

Modèle de Classification de Texte (From Scratch)

Limy-basique est un modèle de classification de texte conçu pour différencier les questions sur les capitales de celles sur les animaux. Entraîné sur le jeu de données Clem27sey/Nacid , ce modèle a été entièrement construit from scratch par Clemylia. Il est idéal pour les tâches de classification binaire et peut être utilisé en tant que base pour des projets similaires.

📌 Utilisation du Modèle

Ce modèle prend une question en entrée et la classe dans l'une des deux catégories suivantes :

• 0 : Questions sur les Animaux 🐾
• 1 : Questions sur les Capitales 🏙️

⚙️ Comment utiliser le modèle avec PyTorch

Pour faire des prédictions, tu dois d'abord charger l'architecture du modèle et ses poids entraînés. Voici un exemple complet, facile à copier-coller, qui te montre comment interroger le modèle.

1. Code de la classe du modèle

import torch
import torch.nn as nn

# Classe du modèle. Elle doit être définie avant de pouvoir charger les poids.
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)
        self.fc = nn.Linear(hidden_dim, output_dim)

    def forward(self, text):
        embedded = self.embedding(text)
        _, (hidden, _) = self.lstm(embedded.view(len(text), 1, -1))
        output = self.fc(hidden.squeeze(0))
        return output

# Tokenizer simple. Il doit aussi être recréé pour traiter le texte.
def simple_tokenizer(text):
    return text.lower().split()

2. Chargement du modèle et prédiction

Ce script télécharge les fichiers du modèle depuis Hugging Face, le charge en mémoire et fait une prédiction.

import json
from huggingface_hub import hf_hub_download

# Téléchargement des fichiers du modèle
repo_id = "Clemylia/Limy-basique"
vocab_path = hf_hub_download(repo_id, "vocab.json")
config_path = hf_hub_download(repo_id, "config.json")
model_path = hf_hub_download(repo_id, "pytorch_model.bin")

# Chargement du vocabulaire et de la configuration pour initialiser le modèle
with open(vocab_path, 'r') as f:
    word_to_idx = json.load(f)

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

# Création de l'instance du modèle
model = SimpleClassifier(
    vocab_size=config['vocab_size'],
    embedding_dim=config['embedding_dim'],
    hidden_dim=config['hidden_dim'],
    output_dim=config['output_dim']
)

# Chargement des poids entraînés et mise en mode évaluation
model.load_state_dict(torch.load(model_path))
model.eval()

# Fonction de prédiction
def predict(question):
    tokens = simple_tokenizer(question)
    token_indices = [word_to_idx.get(token, 0) for token in tokens]
    input_tensor = torch.tensor(token_indices, dtype=torch.long)
    
    with torch.no_grad():
        output = model(input_tensor.view(-1, 1))
    
    prediction = torch.argmax(output, dim=1).item()
    
    if prediction == 0:
        print(f"La question est classée dans la catégorie : Animaux 🐾")
    elif prediction == 1:
        print(f"La question est classée dans la catégorie : Capitales 🏙️")

# Exemples de questions
predict("Quelle est la capitale du Japon ?")
predict("Combien de cœurs a une pieuvre ?")

🤝 Contributeurs

Ce modèle a été créé avec passion par Clemylia