README.md

---
license: mit
language:
- fr
tags:
- mon chien
- prise de décision
- classificateur de texte
- Simply
- Dog
- ia dog
pipeline_tag: text-classification
datasets:
- Clemylia/Canape
---

## 🐶 Documentation du Modèle **Marius**

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

### 🌟 Présentation du Modèle

| Clé | Valeur |
| :--- | :--- |
| **Nom du Modèle** | **Marius** |
| **Auteure** | Clemylia (18 ans, Développeuse d'IA) |
| **Version Actuelle** | v1.0 |
| **Objectif** | Simulation de la prise de décision du chien Marius 🐕 en fonction d'un contexte textuel. |
| **Licence** | (MIT) |
| **Lien Hugging Face** | `Clemylia/Marius |

### 🧠 Aperçu Fonctionnel

Le modèle **Marius** est un classifieur de texte léger, entraîné **entièrement à partir de zéro (from scratch)** par Clemylia. Il est conçu pour prédire l'action la plus probable que le chien Marius (Chien de Clemylia) choisirait parmi trois options, basées sur la phrase fournie par l'utilisateur.

L'objectif est de s'amuser à interpréter le "point de vue" canin sur des situations variées.

### 🎯 Classes de Prédiction (Sorties)

**Marius** classifie la phrase d'entrée dans l'une des trois catégories suivantes :

| ID | Classe (Label) | Description | Emoji |
| :---: | :--- | :--- | :---: |
| **0** | **Rien** | Marius est indifférent ou ne réagit pas (e.g., il dort ou ignore l'événement). | 😴 |
| **1** | **Rouler** | Marius est probablement sur le canapé, prêt à jouer, ou s'ennuie et demande de l'attention (rouler sur le dos est une demande de caresse ou un signe d'amusement). | 🤸 |
| **2** | **Manger** | Marius perçoit une opportunité de nourriture (e.g., bruit de sachet, heure du repas, mention d'un aliment). | 🍖 |

### 🛠️ Utilisation et Installation (Inférence)

Pour utiliser Marius, vous pouvez l'importer dans un environnement Python (ce code fournit un exemple d'inférence).

#### 💻 Exemple de Code

```python
import torch
import torch.nn as nn
import re

# Define the model class (needs to be the same as the training script)
class SimpleTextClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_class):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.fc = nn.Linear(embed_dim, num_class)

    def forward(self, text):
        embedded = self.embedding(text)
        mask = (text != 0).unsqueeze(2).float()
        masked_embedded = embedded * mask
        averaged = masked_embedded.sum(dim=1) / mask.sum(dim=1).clamp(min=1e-9)
        return self.fc(averaged)

# Load the saved model weights
# Make sure vocab_size, embed_dim, and num_classes are defined from previous cells
# You also need the 'vocab' dictionary and 'label_map_reverse' dictionary from previous cells
try:
    model = SimpleTextClassifier(vocab_size, embed_dim, num_classes)
    model.load_state_dict(torch.load('simple_text_classifier.pth'))
    model.eval() # Set the model to evaluation mode
except NameError:
    print("Please ensure 'vocab_size', 'embed_dim', 'num_classes', 'vocab', and 'label_map_reverse' are defined by running previous cells.")

# Function to tokenize text manually (same as in training)
def simple_tokenizer(text):
    text = re.sub(r'[^\w\s]', '', text)
    return text.lower().split()

# Function to convert text to numerical representation (same as in training)
def text_to_sequence(text, vocab):
    return [vocab[word] for word in simple_tokenizer(text) if word in vocab]

# Define the reverse label mapping (from integer to label string)
# This should be the same as the one used during training
label_map_reverse = {0: 'Rouler', 1: 'Rien', 2: 'Manger'} # Ensure this matches your training labels

# Inference function
def predict_action(sentence):
    with torch.no_grad():
        # Preprocess the input sentence
        # Use the vocab built during training
        sequence = text_to_sequence(sentence, vocab)
        if not sequence:
            return "Could not process the input sentence (no known words)."

        # Pad the sequence to the maximum length seen during training or a reasonable fixed length
        # For simplicity here, we'll just process single sentences without padding to a batch max_len
        # A more robust inference would pad to a fixed length or handle batches
        text_tensor = torch.tensor(sequence, dtype=torch.int64).unsqueeze(0) # Add batch dimension

        # Make prediction
        outputs = model(text_tensor)
        _, predicted_class = torch.max(outputs, 1)

        # Convert predicted class to label
        predicted_label = label_map_reverse[predicted_class.item()]
        return predicted_label

# Example usage with French sentences:
french_sentences = [
    "Marius aime bien rouler par terre.",
    "Il n'y a rien à faire ici.",
    "Marius veut manger maintenant.",
    "Je suis dehors, je vais rouler.",
    "On se promène tranquillement.",
]

print("Testing inference with French sentences:")
for sentence in french_sentences:
    predicted_action = predict_action(sentence)
    print(f"Sentence: '{sentence}' -> Predicted Action: {predicted_action}")
```

### 📊 Données d'Entraînement

Ce modèle a été entraîné sur la **petite dataset** de Clemylia : `Clemylia/canape`.

  * **Taille de la Dataset :** **25 exemples** uniques.
  * **Création :** Cette dataset a été créée manuellement par Clemylia, documentant des situations réelles et hypothétiques de son chien Marius pour simuler ses choix.
  * **Méthode :** Le modèle a été développé **from scratch** (entièrement de zéro) sans l'utilisation d'un modèle pré-entraîné existant, démontrant une maîtrise complète du pipeline d'apprentissage.

> 📝 **Note :** La petite taille de la dataset (25 exemples) et le développement *from scratch* font de ce modèle une démonstration de concept puissante. Les prédictions sont **fiables pour le contexte d'entraînement**, mais l'utilisation sur des phrases très éloignées de la dataset initiale pourrait mener à des prédictions inattendues.

### 🛑 Limitations et Bienséance

1.  **Fiabilité Scientifique :** Le modèle est une simulation amusante et **n'a aucune validité scientifique** pour prédire le comportement réel d'un chien.
2.  **Généralisation :** En raison de la petite taille de la dataset (25 exemples), le modèle peut avoir des difficultés à généraliser à des phrases très éloignées des exemples d'entraînement.
3.  **Biais :** Le modèle reflète le biais de l'environnement et des interactions de Marius et de son humaine. Il est optimisé pour les *habitudes* de ce chien spécifique.