\n",
"\n",
"Dans ce TP, nous allons mettre en pratique certaines des méthodes présentées en cours pour localiser des objets dans une image.\n",
"\n",
"En localisation et détection, on cherche à déterminer la position d'un objet, ainsi que sa classe, sous la forme d'une boîte englobante de largeur $b_w$ et hauteur $b_h$, et dont le centre a pour coordonnées le point $(b_x, b_y)$. \n",
"\n",
"
\n",
"
Figure 1: Modèle de boîte englobante utilisé pour la localisation
\n",
"\n",
"Le problème de localisation considère qu'un seul objet est présent sur l'image, alors que le problème de détection cherche à déterminer l'ensemble des objets présents sur l'image.\n",
"\n",
"\n",
"\n",
"Pour commencer, récupérez les images de la base de données :\n"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"id": "2ZjveWpbuNeV"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"fatal: le chemin de destination 'mangeoires_loc' existe déjà et n'est pas un répertoire vide.\n"
]
}
],
"source": [
"!git clone https://github.com/axelcarlier/mangeoires_loc.git"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "LF6aRZLE2-Yl"
},
"source": [
"La base de données consiste en des photographies prises par une caméra reliée à une Raspberry Pi, cachée dans une mangeoire. Plusieurs mangeoires sont disséminées dans la nature en Occitanie, et l'objectif de [ce projet](https://econect.cnrs.fr/) est la reconnaissance des espèces et le comptage des individus qui viennent se poser devant le caméra, afin de suivre l'évolution des populations d'oiseaux et ainsi monitorer la biodiversité.\n",
"\n",
"La base de données qui vous est fournie regroupe 11 espèces d'animaux, majoritairement des oiseaux, désignés par un code : \n",
"\n",
"1. Mésange charbonnière (**MESCHA**)\n",
"2. Verdier d'Europe (**VEREUR**)\n",
"3. Écureuil roux (**ECUROU**)\n",
"4. Pie bavarde (**PIEBAV**)\n",
"5. Sittelle torchepot (**SITTOR**)\n",
"6. Pinson des arbres (**PINARB**)\n",
"7. Mésange noire (**MESNOI**)\n",
"8. Mésange nonnette (**MESNON**)\n",
"9. Mésange bleue (**MESBLE**)\n",
"10. Rouge-gorge (**ROUGOR**)\n",
"11. Accenteur mouchet (**ACCMOU**)\n",
"\n",
"\n",
"\n",
"
\n",
"\n",
"\n",
"
\n",
"
Figure 2: Exemples d'images de la base de données
"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "kxZ6cVouz9Lp"
},
"source": [
"# Localisation et classification d'objet\n",
"\n",
"Dans cette partie, nous allons nous concentrer sur le problème de la localisation d'un seul objet par classe. La base de données a été épurée pour se concentrer uniquement sur ce cas.\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"id": "SBA3fa8RSDpt"
},
"outputs": [],
"source": [
"import PIL\n",
"from PIL import Image\n",
"import csv\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"import tensorflow as tf\n",
"\n",
"from tensorflow import keras\n",
"from tensorflow.keras import layers\n",
"from tensorflow.keras import models\n",
"from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, Dropout, Input\n",
"from tensorflow.keras.models import Model, Sequential\n",
"from tensorflow.keras.optimizers import Adam\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "HKRm5oT-_Qsw"
},
"source": [
"## Préparation des données\n",
"\n",
"Le code ci-dessous permet de charger les données et les formater pour la classification. Prenez le temps de regarder un peu le format des labels $y$.\n",
"Notez que les images sont rendues carrées lors du chargement."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"id": "Q54zSuMvGM-5"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['MESCHA', 'VEREUR', 'ECUROU', 'PIEBAV', 'SITTOR', 'PINARB', 'MESNOI', 'MESNON', 'MESBLE', 'ROUGOR', 'ACCMOU']\n"
]
}
],
"source": [
"# Lecture du CSV contenant les informations relatives à la base de données\n",
"dataset = []\n",
"with open('mangeoires_loc/bd_mangeoires_equilibre.csv', newline='') as csvfile:\n",
"\tfilereader = csv.reader(csvfile, delimiter=' ', quotechar='|')\n",
"\tfor row in filereader:\n",
"\t\tdata = row[0].split(',')\n",
"\t\tif data[0] != 'Data':\n",
"\t\t\tbox = [float(data[5]), float(data[6]), float(data[7]), float(data[8])]\n",
"\t\t\tnew_entry = {'type': data[0], 'specie': data[1], 'path': data[2], 'shape': [float(data[3]), float(data[4])], 'box': box}\n",
"\t\t\tdataset.append(new_entry)\n",
"\n",
"# Nombre de classes de la base de données et intitulé des classes\n",
"class_labels = list(dict.fromkeys([item['specie'] for item in dataset]))\n",
"num_classes = len(class_labels)\n",
"\n",
"# Extraction des données d'apprentissage et de test \n",
"dataset_train = [item for item in dataset if item['type']=='TRAIN']\n",
"dataset_test = [item for item in dataset if item['type']=='TEST']\n",
"\n",
"print(class_labels)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"id": "JPzqdJBVJLWJ"
},
"outputs": [],
"source": [
"def build_localization_tensors(image_size, dataset, num_classes):\n",
" # Préparation des structures de données pour x et y\n",
" x = np.zeros((len(dataset), image_size, image_size, 3))\n",
" y = np.empty((len(dataset), num_classes + 5)) # 1 + 4 + num_classes : présence / boîte englobante / classes\n",
"\n",
" # Compteur de parcours du dataset\n",
" i = 0\n",
"\n",
" for item in dataset:\n",
" # Lecture de l'image\n",
" img = Image.open('mangeoires_loc/' + item['path'])\n",
" # Mise à l'échelle de l'image\n",
" img = img.resize((image_size,image_size), Image.ANTIALIAS)\n",
" # Remplissage de la variable x\n",
" x[i] = np.asarray(img)\n",
"\n",
" y[i, 0] = 1 # Un objet est toujours présent !\n",
"\n",
" # Coordonnées de boîte englobante\n",
" img_shape = item['shape']\n",
" box = item['box']\n",
" bx = (box[0] + (box[2] - box[0])/2)/img_shape[0]\n",
" by = (box[1] + (box[3] - box[1])/2)/img_shape[1]\n",
" bw = (box[2] - box[0])/img_shape[0]\n",
" bh = (box[3] - box[1])/img_shape[1]\n",
" y[i, 1] = bx\n",
" y[i, 2] = by\n",
" y[i, 3] = bw\n",
" y[i, 4] = bh\n",
"\n",
" # Probabilités de classe, sous la forme d'une one-hot vector\n",
" label = class_labels.index(item['specie'])\n",
" classes_probabilities = keras.utils.to_categorical(label, num_classes=num_classes)\n",
" y[i, 5:] = classes_probabilities\n",
"\n",
" i = i+1\n",
"\n",
" return x, y\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "fnlljZWc_i1L"
},
"source": [
"Séparation des données d'entraînement pour extraire un ensemble de validation, et pré-traitement des données."
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"id": "FJLRiuFX_VPL"
},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/tmp/ipykernel_3171614/3333676307.py:13: DeprecationWarning: ANTIALIAS is deprecated and will be removed in Pillow 10 (2023-07-01). Use Resampling.LANCZOS instead.\n",
" img = img.resize((image_size,image_size), Image.ANTIALIAS)\n"
]
}
],
"source": [
"from sklearn.model_selection import train_test_split\n",
"\n",
"\n",
"# Pour la suite du TP on considèrera des images de taille 64x64x3\n",
"# Augmenter cette valeur donnerait de meilleurs résultats mais nécessiterait des calculs plus long.\n",
"IMAGE_SIZE = 64\n",
"\n",
"# Lecture des données d'entraînement et de test\n",
"x, y = build_localization_tensors(IMAGE_SIZE, dataset_train, num_classes)\n",
"x_test, y_test = build_localization_tensors(IMAGE_SIZE, dataset_test, num_classes)\n",
"\n",
"#Extraction d'un ensemble de validation\n",
"x_train, x_val, y_train, y_val = train_test_split(x, y, test_size=0.10, random_state=42)\n",
"\n",
"# Pour améliorer l'entraînement, on peut centrer-réduire les coordonnées des bounding boxes...\n",
"y_std = np.std(y_train, axis=0)\n",
"y_mean = np.mean(y_train, axis=0)\n",
"y_train[...,1:5] = (y_train[...,1:5] - y_mean[1:5])/y_std[1:5]\n",
"y_val[...,1:5] = (y_val[...,1:5] - y_mean[1:5])/y_std[1:5]\n",
"y_test[...,1:5] = (y_test[...,1:5] - y_mean[1:5])/y_std[1:5]\n",
"\n",
"# ... et normaliser les valeurs de couleur\n",
"x_train = x_train/255\n",
"x_val = x_val/255\n",
"x_test = x_test/255"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "DE4wQYq3AKnA"
},
"source": [
"## Fonctions utiles"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "n6NBpMtaM-C0"
},
"source": [
"Une fonction de calcul de l'intersection sur union, qui nous sera utile pour les métriques d'évaluation de nos méthodes :\n",
"\n",
"$$ IoU (R_1, R_2) = \\frac{\\mathcal{A} (R_1 \\cap R_2)}{\\mathcal{A} (R_1 \\cup R_2)} = \\frac{\\mathcal{A} (R_1 \\cap R_2)}{\\mathcal{A} (R_1) + \\mathcal{A} (R_2) - \\mathcal{A} (R_1 \\cap R_2)} $$ \n",
"\n",
"
\n",
"\n",
"
\n"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"id": "rr-O1XuwLoL3"
},
"outputs": [],
"source": [
"### A COMPLETER\n",
"def intersection_sur_union(box1, box2):\n",
" \"\"\"\n",
" Calcul de l'intersection sur union entre deux rectangles box1 et box2\n",
"\n",
" Arguments:\n",
" box1, box2 -- les coordonnées des deux rectangles, chacun sous la forme [cx, cy, w, h]\n",
" où (cx, cy) désigne les coordonnées du centre du rectangle, \n",
" w sa largeur et h sa hauteur\n",
"\n",
" Retourne :\n",
" iou -- la valeur d'intersection sur union entre les deux rectangles \n",
" \"\"\"\n",
"\n",
" # unpacking\n",
" cx1, cy1, w1, h1 = box1\n",
" cx2, cy2, w2, h2 = box2\n",
"\n",
" # haut gauche R1\n",
" x1 = cx1 - w1/2\n",
" y1 = cy1 - h1/2\n",
" \n",
" # bas droite R1\n",
" x2 = cx1 + w1/2\n",
" y2 = cy1 + h1/2\n",
"\n",
" # haut gauche R2\n",
" x3 = cx2 - w2/2\n",
" y3 = cy2 - h2/2\n",
" \n",
" # bas droite R2\n",
" x4 = cx2 + w2/2\n",
" y4 = cy2 + 2/2\n",
"\n",
" # haut gauche intersection\n",
" xi1 = max(x1, x3)\n",
" yi1 = max(y1, y3)\n",
"\n",
" # bas droite intersection\n",
" xi2 = min(x2, x4)\n",
" yi2 = min(y2, y4)\n",
"\n",
" # dimension de l'intersection\n",
" wi = abs(xi2 - xi1)\n",
" hi = abs(yi2 - yi1)\n",
"\n",
" # calcul des aires\n",
" aR1iR2 = wi * hi\n",
" aR1 = w1 * h1\n",
" aR2 = w2 * h2\n",
"\n",
" return aR1iR2 / (aR1 + aR2 - aR1iR2)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"id": "SdqAFWFxRx8l"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.2\n",
"0.0\n"
]
}
],
"source": [
"print(intersection_sur_union([2.5, 2, 1, 4], [2, 3, 4, 2])) # Résultat attendu : 0.2\n",
"print(intersection_sur_union([2.5, 2, 1, 4], [5, 3, 4, 2])) # Résultat attendu : 0.0"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "RLpMJGi3QC9i"
},
"source": [
"Calcul des différentes métriques : \n",
"\n",
"$$ P = \\frac{TP}{TP + FP} $$\n",
"\n",
"$$ R = \\frac{TP}{TP + FN} $$\n",
"\n",
"$$ F1 = \\frac{2}{\\frac{1}{P} + \\frac{1}{R}} $$\n",
"\n",
"où $TP$ désigne le nombre de vrais positifs, $FP$ le nombre de faux positifs, $FN$ le nombre de faux négatifs, $P$ la précision, $R$ le rappel et $F1$ le F1-score.\n",
"\n",
"On considère souvent qu'une détection est correcte si la classification est valide et que l'intersection sur union entre vérité terrain et prédiction est supérieure à 0.5 (on utilisera un seuil modifiable *iou_thres*)."
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"id": "5e_aIvjXLq32"
},
"outputs": [],
"source": [
"# A COMPLETER\n",
"def global_accuracy(y_true, y_pred, iou_thres=0.5):\n",
" \"\"\"\n",
" Calcul, pour chaque classe de la précision, du rappel et du F1-score ainsi \n",
" que du pourcentage global de bonnes détections.\n",
"\n",
" Arguments:\n",
" y_true -- les labels de la vérité terrain, de dimension (M, 1+4+N) où M désigne\n",
" le nombre d'éléments du dataset et N le nombre de classes (11 dans notre cas)\n",
" y_pred -- les labels prédits par un modèle, de dimension (M, 1+4+N) \n",
" iou_thres -- seuil d'intersection sur union entre une boîte \"vérité-terrain\" et \n",
" une boite prédite au-dessus duquel on considère que la prédiction est correcte \n",
"\n",
" Retourne :\n",
" class_res -- liste de longueur N contenant des dictionnaires sous la forme \n",
" {\"Précision\": p, \"Rappel\": r, \"F-score\": f} résumant les métriques\n",
" précision, rappel et F1-score pour chacune des classes.\n",
" accuracy -- pourcentage global de bonnes détections\n",
" \"\"\"\n",
" # Initialisation des métriques : nombre de vrais positifs (TP), faux positifs (FP)\n",
" # et faux négatifs (FN) pour chaque classe\n",
" class_metrics = []\n",
" for i in range(num_classes):\n",
" class_metrics.append({'TP': 0, 'FP': 0, 'FN': 0})\n",
"\n",
" # Nombres de détections correctes et de détections incorrectes\n",
" total_correct_detections = 0\n",
" total_incorrect_detections = 0\n",
" for i in range(y_true.shape[0]):\n",
" # Labels vérité-terrain et prédits\n",
" groundtruth_label = np.argmax(y_true[i,5:])\n",
" predicted_label = np.argmax(y_pred[i,5:])\n",
"\n",
" # Coordonnées de boîtes englobantes réelles et prédites\n",
" bx_true = (y_true[i,1]*y_std[1] + y_mean[1])\n",
" by_true = (y_true[i,2]*y_std[2] + y_mean[2])\n",
" bw_true = (y_true[i,3]*y_std[3] + y_mean[3])\n",
" bh_true = (y_true[i,4]*y_std[4] + y_mean[4]) \n",
" bx_pred = (y_pred[i,1]*y_std[1] + y_mean[1])\n",
" by_pred = (y_pred[i,2]*y_std[2] + y_mean[2])\n",
" bw_pred = (y_pred[i,3]*y_std[3] + y_mean[3])\n",
" bh_pred = (y_pred[i,4]*y_std[4] + y_mean[4]) \n",
"\n",
" # Calcul de l'intersection sur union\n",
" iou = intersection_sur_union([bx_true, by_true, bw_true, bh_true], [bx_pred, by_pred, bw_pred, bh_pred])\n",
" \n",
" # Si la détection est correcte : \n",
" if groundtruth_label == predicted_label and iou > iou_thres:\n",
" total_correct_detections += 1\n",
" class_metrics[predicted_label][\"TP\"] += 1\n",
" else:\n",
" total_incorrect_detections += 1\n",
" class_metrics[predicted_label][\"FP\"] += 1\n",
" class_metrics[groundtruth_label][\"FN\"] += 1\n",
"\n",
"# for i in range(num_classes):\n",
"# print(class_metrics[i])\n",
"\n",
" class_res = []\n",
" for i in range(num_classes):\n",
" TP = class_metrics[i][\"TP\"]\n",
" FP = class_metrics[i][\"FP\"]\n",
" FN = class_metrics[i][\"FN\"]\n",
" if (TP or FP) and (TP or FN): \n",
" P = TP / (TP + FP)\n",
" R = TP / (TP + FN)\n",
" F_score = 2 / ( 1/P + 1/R )\n",
" else:\n",
" P = 0\n",
" R = 0\n",
" F_score = 0\n",
" class_res.append({'Precision': P, 'Rappel': R, 'F-score': F_score})\n",
"\n",
" accuracy = total_correct_detections / (total_correct_detections + total_incorrect_detections)\n",
" return class_res, accuracy"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"id": "AOOWhuk4VBZE"
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"La précision globale est de 66.7%\n",
"\n",
"--------------------------------------------\n",
"| Classe | Précision | Rappel | F1-score |\n",
"--------------------------------------------\n",
"| Classe 1 | 1.00 | 1.00 | 1.00 |\n",
"--------------------------------------------\n",
"| Classe 2 | 0.00 | 0.00 | 0.00 |\n",
"--------------------------------------------\n",
"| Classe 3 | 0.50 | 1.00 | 0.67 |\n",
"--------------------------------------------\n"
]
}
],
"source": [
"num_class_test = 3\n",
"class_labels_test = ['Classe 1', 'Classe 2', 'Classe 3']\n",
"y_true_test = np.ones((num_class_test,8))\n",
"y_true_test[0,:2] = [0.5, 0.5]\n",
"y_true_test[0, 5:] = [1, 0, 0]\n",
"y_true_test[1,:2] = [0.5, 0.5]\n",
"y_true_test[1, 5:] = [0, 1, 0]\n",
"y_true_test[2,:2] = [0.5, 0.5]\n",
"y_true_test[2, 5:] = [0, 0, 1]\n",
"y_pred_test = np.ones((num_class_test,8))\n",
"y_pred_test[0,:2] = [0.6, 0.6]\n",
"y_pred_test[0, 5:] = [1, 0, 0]\n",
"y_pred_test[1,:2] = [2.5, 2.5]\n",
"y_pred_test[1, 5:] = [0, 0, 1]\n",
"y_pred_test[2,:2] = [0.6, 0.6]\n",
"y_pred_test[2, 5:] = [0, 0, 1]\n",
"\n",
"class_res_test, acc_test = global_accuracy(y_true_test, y_pred_test)\n",
"\n",
"print(f\"La précision globale est de {100 * acc_test:.1f}%\")\n",
"\n",
"print()\n",
"print(\"--------------------------------------------\")\n",
"print(\"| Classe | Précision | Rappel | F1-score |\")\n",
"print(\"--------------------------------------------\")\n",
"for i in range(num_class_test):\n",
" print(f\"| {class_labels_test[i]:9s}| {class_res_test[i]['Precision']:.2f} | {class_res_test[i]['Rappel']:.2f} | {class_res_test[i]['F-score']:.2f} |\")\n",
" print(\"--------------------------------------------\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "Q1Tg4VFVVB-w"
},
"source": [
"**Affichage attendu :**\n",
"```\n",
"La précision globale est de 66.7%\n",
"\n",
"--------------------------------------------\n",
"| Classe | Précision | Rappel | F1-score |\n",
"--------------------------------------------\n",
"| Classe 1 | 1.00 | 1.00 | 1.00 |\n",
"--------------------------------------------\n",
"| Classe 2 | 0.00 | 0.00 | 0.00 |\n",
"--------------------------------------------\n",
"| Classe 3 | 0.50 | 1.00 | 0.67 |\n",
"--------------------------------------------\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "cMntCEgkANMg"
},
"source": [
"La fonction ci-dessous permet de calculer l'intersection sur union sur des tenseurs (et non des tableaux numpy), elle sera donc utilisable comme métrique pendant l'entraînement."
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {
"id": "tVk9cB1WAMUK"
},
"outputs": [],
"source": [
"def compute_iou(y_true, y_pred):\n",
" ### \"Dénormalisation\" des coordonnées des boîtes englobantes\n",
" pred_box_xy = y_pred[..., 0:2]* y_std[0:2] + y_mean[0:2]\n",
" true_box_xy = y_true[..., 0:2]* y_std[0:2] + y_mean[0:2]\n",
"\n",
" ### \"Dénormalisation\" des largeur et hauteur des boîtes englobantes\n",
" pred_box_wh = y_pred[..., 2:4] * y_std[2:4] + y_mean[2:4]\n",
" true_box_wh = y_true[..., 2:4] * y_std[2:4] + y_mean[2:4]\n",
" \n",
" # Calcul des coordonnées minimales et maximales des boiptes englobantes réelles\n",
" true_wh_half = true_box_wh / 2.\n",
" true_mins = true_box_xy - true_wh_half\n",
" true_maxes = true_box_xy + true_wh_half\n",
" \n",
" # Calcul des coordonnées minimales et maximales des boiptes englobantes prédites\n",
" pred_wh_half = pred_box_wh / 2.\n",
" pred_mins = pred_box_xy - pred_wh_half\n",
" pred_maxes = pred_box_xy + pred_wh_half \n",
" \n",
" # Détermination de l'intersection des boîtes englobantes\n",
" intersect_mins = tf.maximum(pred_mins, true_mins)\n",
" intersect_maxes = tf.minimum(pred_maxes, true_maxes)\n",
" intersect_wh = tf.maximum(intersect_maxes - intersect_mins, 0.)\n",
" intersect_areas = intersect_wh[..., 0] * intersect_wh[..., 1]\n",
" \n",
" # Aire des boîtes englobantes prédites et réelles\n",
" true_areas = true_box_wh[..., 0] * true_box_wh[..., 1]\n",
" pred_areas = pred_box_wh[..., 0] * pred_box_wh[..., 1]\n",
"\n",
" # Aire de l'union des boîtes prédites et réelles\n",
" union_areas = pred_areas + true_areas - intersect_areas\n",
"\n",
" iou_scores = tf.truediv(intersect_areas, union_areas)\n",
" return iou_scores\n",
"\n",
"def iou():\n",
" def iou_metrics(y_true, y_pred):\n",
" return compute_iou(y_true, y_pred)\n",
" iou_metrics.__name__= \"IoU\"\n",
" return iou_metrics"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "vidE3XHlAkst"
},
"source": [
"Visualisation des données et labels"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {
"id": "8yotZHKgAiV1"
},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
"