---
tags:
- text-classification
- from-scratch
license: mit
datasets:
- Clem27sey/Nacid
language:
- fr
pipeline_tag: text-classification
---

### `Limy-basique` 🚀

![Limy-basique](http://www.image-heberg.fr/files/17580093493935949439.jpg)
### 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**