PooperSmash

PooperSmash est un projet de computer vision qui vise à entraîner un modèle de deep learning capable de détecter automatiquement si un chien est en train de faire ses besoins ou non à partir d’images. Le système s’appuie sur un réseau de neurones convolutionnel (CNN) en transfer learning, entraîné sur un jeu de données annoté contenant des photos de chiens dans différentes postures, classées en deux catégories : pooping et not_pooping. Les images sont référencées via un fichier de labels et chargées dynamiquement par le pipeline PyTorch (datasets, dataloaders, entraînement, évaluation et scripts d’inférence). À terme, ce modèle pourra servir de base à une application capable d’analyser automatiquement des images ou des flux vidéo (caméras de jardin, par exemple) pour détecter ce type de comportement canin de manière robuste et automatisée.

Architecture

poopersmash/
├── 📁 assets
├── 📁 data
│   ├── 📁 annotations
│   │   └── 📄 labels.csv               # Labels des images
│   ├── 📁 processed
│   │   ├── 📁 test
│   │   │   ├── 📁 not_pooping
│   │   │   └── 📁 pooping
│   │   ├── 📁 train
│   │   │   ├── 📁 not_pooping
│   │   │   └── 📁 pooping
│   │   └── 📁 val
│   │       ├── 📁 not_pooping
│   │       └── 📁 pooping
│   └── 📁 raw
│       ├── 📁 heic
│       └── 📁 jpg                      # Photos originales
│           ├── 🖼️ img_1.jpg
│           ├── 🖼️ img_10.jpg
│           ├── 🖼️ ...
├── 📁 notebooks
│   └── 📄 exploration.ipynb            # Tests rapides / visualisation
├── 📁 scripts
│   ├── 📄 prepare_data.sh              # Script bash pour setup data
│   └── 📄 run_train.sh                 # Script bash pour lancer l'entraînement
├── 📁 src
│   ├── 📁 configs
│   │   └── ⚙️ config_classif.yaml      # Hyperparamètres & chemins
│   ├── 📁 data
│   │   ├── 🐍 dataset.py # Dataset PyTorch
│   │   ├── 🐍 split_dataset.py         # Data augmentation & prétraitements
│   │   └── 🐍 transforms.py            # Script pour split train/val/test
│   ├── 📁 inference
│   │   ├── 🐍 predict_folder.py        # Prédire sur une image
│   │   └── 🐍 predict_image.py         # Prédire sur un dossier d'images
│   ├── 📁 models
│   │   └── 🐍 model.py                 # Définition / chargement du modèle
│   ├── 📁 serving
│   │   └── 🐍 api_fastapi.py           # (optionnel) API REST pour ton modèle
│   └── 📁 training
│       ├── 🐍 evaluate.py
│       ├── 🐍 train.py
│       └── 🐍 utils.py
├── ⚙️ .gitignore
├── 📝 README.md                        # Documentation du projet
├── 🐍 convert_img.py                   # Convertisseur d'image du format heic -> png
└── 📄 requirements.txt                 # Dépendances

Environnement virtuel

• Création: python3 -m venv .venv
• Activation: source .venv/bin/activate
• Installer les dépendances sur un nouvel environnement: pip install -r requirements.txt
• Générer le fichier "requirements.txt": pip freeze > requirements.txt
• Désactiver: deactivate

Classification d’image simple

Entrée : une image.
Sortie :

• 0 = pas en train de faire caca

• 1 = en train de faire caca → Le plus simple pour un premier prototype.

• Détection d’objet + état

• Le modèle doit localiser le chien et dire pour chaque chien s’il est en train de faire caca ou non. Ex : YOLO/Faster R-CNN avec deux classes : dog_normal, dog_pooping.

Les données (le plus gros du travail)

Splits

• train = apprendre
• val = chosir les hyperparamètres, détecter l'overfitting
• test = mesurer la vraie généralisation sur du jamais vu

Répartitions (ex: 100 images):

• Train : ~35 pooping / 35 not_pooping (70%)
• Val : ~7–8 / 7–8 (15%)
• Test : ~7–8 / 7–8 (15%)

Types de données

Besoin de 2 types d’images :

• Positives : chiens en train de faire caca (différentes races, différents angles (profil, arrière, léger ¾), différentes distances et arrière-plans (jardin, trottoir, parc...)).
• Négatives : chiens debout, couchés, assis, en train de courir, renifler, etc (idéalement aussi des chiens accroupis mais pas en train de faire caca (pour rendre le problème dur)).
• Autres animaux / objets qui pourraient être confondus (chats, statues, etc.)

⚠️ Attention à :

• Le respect de la vie privée si tu filmes dans des lieux publics (visages humains, plaques d’immatriculation → floutage).
• Les conditions d’utilisation des images trouvées sur internet.

Annotation

Labellisation des données/images dans le fichiers CSV labels.csv comme ceci:

image_path,label,split
data/raw/img_0001.jpg,pooping,train
data/raw/img_0002.jpg,not_pooping,train
data/raw/img_0003.jpg,pooping,val
data/raw/img_0004.jpg,not_pooping,test
...

Pour la classification

Frameworks typiques :

• PyTorch (très populaire, flexible)
• TensorFlow / Keras (plus “high-level”)

Modèles adaptés :

• ResNet-18 / 34 EfficientNet
• MobileNet (si tu veux le mettre sur mobile, Raspberry, etc.)

Principe :

• Charger un modèle pré-entraîné.
• Remplacer la dernière couche par un layer avec 2 sorties (pooping / not_pooping).
• Entrainer sur ton dataset.

Schéma PyTorch (juste pour visualiser) :

• model = torchvision.models.resnet18(weights="IMAGENET1K_V1")
• num_features = model.fc.in_features
• model.fc = nn.Linear(num_features, 2) # 2 classes

Pour la détection d’objet, tu peux partir sur :

• YOLOv5/YOLOv8 (Ultralytics)
• ou Detectron2 (Facebook)

Prétraitement & augmentation

Pour que ton modèle généralise bien, tu dois augmenter les données :

• Redimensionnement (ex : 224×224 pour ResNet, 640×640 pour certains YOLO)
• Flip horizontal (un chien qui fait caca dans un sens ou dans l’autre, c’est pareil 😅)

Légères transformations :

• rotation légère (±10°)
• changement de luminosité/contraste
• zoom / crop

Évite les transformations trop extrêmes qui déforment la posture.

Entraînement (classification)

Hyperparamètres de base :

• Batch size : 16 ou 32
• Learning rate : 1e-3 ou 1e-4 (avec scheduler)
• Optimiseur : Adam ou SGD

Boucle d’entraînement pour chaque batch :

• Entrée : images
• Sortie : logits (2 valeurs)
• Calcul de la loss : CrossEntropyLoss
• Backpropagation + update des poids

Suivi, sur le set de validation, suivre :

• accuracy
• f1-score pour chaque classe
• matrice de confusion (voir si le modèle confond beaucoup “normal” vs “pooping”)

Lancer l'entrainement (depuis la racine du projet):

# (optionnel) créer un venv
python -m venv .venv
source .venv/bin/activate  # sur Windows: .venv\Scripts\activate

# installer les dépendances
pip install torch torchvision pandas pillow scikit-learn pyyaml

# lancer le training
export PYTHONPATH=.
python src/training/train_from_csv.py --config src/configs/config_classif.yaml

Récap ultra-court

1. Formuler le problème : classification binaire (pooping / not_pooping).
2. Collecter des données : beaucoup d’images positives et négatives variées.
3. Annoter : organiser les images ou dessiner des bounding boxes.
4. Choisir un modèle pré-entraîné : ResNet/EfficientNet ou YOLO pour la détection.
5. Entraîner avec du transfer learning + data augmentation.
6. Évaluer sérieusement sur des cas réels / difficiles.
7. Déployer (API, mobile, edge…).

Test sur image

Tester sur une seule image (via le predict_image.py):

export PYTHONPATH=.

python src/inference/predict_image.py \
    path/vers/une_image.jpg \
    --ckpt runs/dog_pooping_from_csv_v1/best_model.pt

Sortie typique: Prédiction : pooping (confiance = 0.93)

Tester sur tout un dossier (via le predict_folder.py):

python src/inference/predict_folder.py \
    data/mes_images_test \
    --ckpt runs/dog_pooping_from_csv_v1/best_model.pt \
    --csv results/preds.csv

Sortie typique:

data/mes_images_test/img_01.jpg: pooping (confiance = 0.88)
data/mes_images_test/img_02.jpg: not_pooping (confiance = 0.97)
...

📬 Contact