| --- |
| tags: |
| - text-classification |
| - from-scratch |
| license: mit |
| datasets: |
| - Clem27sey/Nacid |
| language: |
| - fr |
| pipeline_tag: text-classification |
| --- |
| |
| ### `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** |
