CoolFace
Modelpublic

Finisha-LLM/Limy-basique

sourceHugging Facemitupdated 1y agoView on Hugging Face
1likes14downloads
Model Card

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

python
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.

python
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