README.md

---
language: fr
license: mit
base_model: Clemylia/Limy-basique
pipeline_tag: text-classification
---
# 📚 Documentation Officielle du Modèle 💖 Limy-mini

![Limy](http://www.image-heberg.fr/files/17587820602737201097.jpg)

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

| Caractéristique | Détail ✨ |
| :--- | :--- |
| **Identifiant du Dépôt** | `Clemylia/Limy-mini` |
| **Modèle de Base (Ancestral)** | `Clemylia/Limy-basique` (Original *from scratch*) |
| **Tâche** | Classification de Texte (Text Classification) |
| **Classes Détectées** | **0** : Animaux 🐾 (Questions sur la faune) <br> **1** : Capitales 🏙️ (Questions sur la géographie urbaine / les villes) |
| **Langue** | Français (fr) 🇫🇷 |
| **Licence** | MIT |

-----

## 🎯 Objectif du Fine-Tuning

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

| Objectif | Résultat Obtenu ✅ |
| :--- | :--- |
| **Robustesse** | Améliorer la capacité du modèle à gérer des phrases complexes, ambiguës ou plus longues. |
| **Étendue des Phrases** | Passer d'un ensemble de données très restreint à un jeu d'entraînement de **92 exemples uniques** sur les deux classes. |
| **Performance** | Réduire l'erreur de classification (la *loss*) pour une meilleure précision. |

**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 :

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

```python
# 💖 É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.).