{"cells":[{"cell_type":"markdown","id":"f821f46c","metadata":{"id":"f821f46c"},"source":["# Introduction à l'intelligence artificielle et à l'apprentissage automatique\n","\n","Bienvenue dans ce notebook qui a pour objectif principal de découvrir l'apprentissage automatique (en anglais, le _machine learning_) au travers de la classification de chiffres manuscrits.\n","\n","Un [notebook](https://en.wikipedia.org/wiki/Project_Jupyter) est une page web qui comporte des cellules de texte (généralement en langage [markdown](https://fr.wikipedia.org/wiki/Markdown)) et des cellules de code (Python, C++, etc.) qui peuvent être exécutées à l'intérieur du notebook.\n","\n","Dans ce notebook, nous allons principalement faire de la classification d'images, ici la classification de chiffres manuscrits, avec la célèbre base de données [MNIST](http://yann.lecun.com/exdb/mnist/). Cette base de données contient 60000 images pour entrainer un modèle de machine learning, et 10000 images pour le tester : on n'entraine jamais avec les données de test, car ce serait comme réviser avec le sujet de l'examen, et cela ne permettrait pas d'évaluer les capacités de généralisation du modèle.\n","\n","Voici quelques exemples d'images contenus dans la base de données :\n","\n","\n","\n","\n","\n","
"]},{"cell_type":"markdown","id":"475d3da2","metadata":{"id":"475d3da2"},"source":["Commençons par importer les packages Python nécessaires :"]},{"cell_type":"code","execution_count":null,"id":"15e20429","metadata":{"id":"15e20429"},"outputs":[],"source":["import time\n","\n","import matplotlib.pyplot as plt\n","import numpy as np\n","import torch\n","import torchvision\n","import torch.nn as nn\n","import torch.nn.functional as F\n","import torch.optim as optim\n","\n","plt.rcParams[\"image.cmap\"] = \"jet\" # Colors for heatmaps\n","DATADIR = \"./data\" # Folder to download the data\n","np.set_printoptions(linewidth=1000) # Avoid breaking lines when printing arrays"]},{"cell_type":"markdown","id":"69d4297b","metadata":{"id":"69d4297b"},"source":["# Présentation de la base MNIST\n","\n","La cellule suivante charge les données de MNIST, un ensemble d'images en niveau de gris, de taille `28 x 28`. \n","\n","> La première fois que la cellule est exécutée, les données sont téléchargées depuis un serveur externe."]},{"cell_type":"code","execution_count":null,"id":"e9162f92","metadata":{"id":"e9162f92"},"outputs":[],"source":["visu_set = torchvision.datasets.MNIST(DATADIR, train=True, download=True)"]},{"cell_type":"markdown","id":"1c74512f","metadata":{"id":"1c74512f"},"source":["Visualisons quelques unes de ces images :"]},{"cell_type":"code","execution_count":null,"id":"ec8b3604","metadata":{"id":"ec8b3604"},"outputs":[],"source":["index = 7\n","image, label = visu_set[index]\n","image = 255 - np.asarray(image) # Make 0 white and 255 black\n","plt.imshow(image, cmap=\"gray\")\n","plt.title(f\"Image de la classe {label} et de taille {image.shape}\")\n","plt.show()"]},{"cell_type":"markdown","id":"c047028f","metadata":{"id":"c047028f"},"source":["Les images de MNIST sont des images en niveau de gris (pas en couleur) et ont une taille de `28 x 28`. Une image est donc un tableau ou une matrice avec 28 lignes et 28 colonnes, et les valeurs vont de 0 à 255 (entier 8 bits non signé).\n","\n","La cellule suivante affiche le tableau (un array NumPy) pour l'image suivante :\n","\n","\n","\n","\n","\n","
\n","\n","On a représenté les pixels avec des niveaux de gris, ou les petites valeurs (vers `0`) tendent vers le blanc, tandis que les grandes valeurs (vers `255`) tendent vers le noir."]},{"cell_type":"code","execution_count":null,"id":"80892f4e","metadata":{"id":"80892f4e"},"outputs":[],"source":["index = 7\n","image, label = visu_set[index]\n","image = np.asarray(image) # Convert from PIL image to NumPy array\n","print(image)"]},{"cell_type":"markdown","id":"3e2233cc","metadata":{"id":"3e2233cc"},"source":["Le but de la classification d'images est de trouver un modèle (une fonction mathématique, un algorithme, une suite d'opérations numériques) sur ce tableau, pour qu'en sortie, le modèle dise que ce tableau / cette image fait partie de la catégorie \"3\"."]},{"cell_type":"markdown","id":"26ce8e07","metadata":{"id":"26ce8e07"},"source":["# Classification basée sur un seul pixel\n","\n","Nous allons commencer très simplement en construisant un classifier (une fonction ou un modèle qui retourne le numéro de la classe à laquelle appartient l'image d'entrée).\n","\n","Pour simplifier, on commence par construire un classifier pour discriminer les `0` des `1`, le jeu de donnée (_dataset_) ne va contenir que des zéros et des uns.\n","\n","\n","\n","\n","\n","
\n","\n","\n","\n","\n","\n","
"]},{"cell_type":"markdown","id":"210f48ec","metadata":{"id":"210f48ec"},"source":["Commençons par sélectionner uniquement les images de `0` et de `1` :"]},{"cell_type":"code","execution_count":null,"id":"5bbfe508","metadata":{"id":"5bbfe508"},"outputs":[],"source":["def select_classes(dataset, classes):\n"," if isinstance(classes, int):\n"," classes = [classes]\n"," output = []\n"," for image, label in dataset:\n"," if label in classes:\n"," output.append((np.asarray(image), label))\n"," return output"]},{"cell_type":"code","execution_count":null,"id":"2636d88b","metadata":{"scrolled":false,"id":"2636d88b"},"outputs":[],"source":["classes_0_1 = select_classes(visu_set, [0, 1])"]},{"cell_type":"code","execution_count":null,"id":"fc5efb23","metadata":{"id":"fc5efb23"},"outputs":[],"source":["def one_pixel_classification(dataset, i=14, j=14):\n"," \"\"\"Classify input images in 0 or 1 depending on value of pixel at location (i, j)\"\"\"\n"," predictions, labels = [], []\n"," for image, label in dataset:\n"," if image[i][j] > 0:\n"," prediction = 1\n"," else:\n"," prediction = 0\n"," predictions.append(prediction)\n"," labels.append(label)\n"," return predictions, labels"]},{"cell_type":"markdown","id":"9b7dd6fb","metadata":{"id":"9b7dd6fb"},"source":["Évaluons maintenant les performances de cet algorithme. La fonction suivante calcule le taux de réussite du classifier (l'_accuracy_), en comptant combien de prédictions sont correctes par rapport à l'étiquette (_label_) des images."]},{"cell_type":"code","execution_count":null,"id":"cdc08181","metadata":{"id":"cdc08181"},"outputs":[],"source":["def compute_accuracy(predictions, labels):\n"," nb_correct = 0\n"," for label, prediction in zip(labels, predictions):\n"," if prediction == label:\n"," nb_correct = nb_correct + 1\n"," return 100*nb_correct/len(labels)"]},{"cell_type":"markdown","id":"c4615187","metadata":{"id":"c4615187"},"source":["La cellule suivante effectue la classification et calcule la performance :"]},{"cell_type":"code","execution_count":null,"id":"95387ef9","metadata":{"id":"95387ef9"},"outputs":[],"source":["predictions, labels = one_pixel_classification(classes_0_1, 14, 14)\n","accuracy = compute_accuracy(predictions, labels)\n","print(f\"The accuracy is {accuracy:.2f} %\")"]},{"cell_type":"markdown","id":"aa07d875","metadata":{"id":"aa07d875"},"source":["En regardant \"simplement\" le pixel du milieu de l'image, le classifier a pu discriminer les images de `0` et de `1`.\n","\n","Ce classifier n'est pas très \"puissant\", et ne marche que pour les images de `0` et `1`. Si on souhaite reconnaitre tous les autres chiffres, il faudra trouver une meilleure méthode."]},{"cell_type":"markdown","id":"8373b021","metadata":{"id":"8373b021"},"source":["# Template matching\n","\n","Le but du _template matching_ est d'estimer à quel point un signal d'entrée (dans notre cas une image, un signal 2d) coincide avec un signal de référence, qu'on va appeler un _template_. C'est un peu comme si on a un moule (le _template_) et si l'objet \"rentre dans le moule\", alors on dira qu'il correspond au moule, et donc à la classe représentée par le template.\n","\n","Dans notre cas de la classification de chiffres, on va construire un _template_ pour chaque chiffre (de 0 à 9), puis on estimera la ressemblance entre un chiffre $x \\in \\mathbb{R}^{28 \\times 28}$ et un template $w \\in \\mathbb{R}^{28 \\times 28}$ en calculant la corrélation qui existe entre les pixels de l'image et les pixels du _template_.\n","\n","$$s(x, w) = \\sum_{i=0}^{28 \\times 28} w_i x_i $$"]},{"cell_type":"markdown","id":"7247e15c","metadata":{"id":"7247e15c"},"source":["La fonction suivante prend en entrée un jeu d'apprentissage (_training dataset_) et calcule la moyenne de tous les éléments ayant la même étiquette (_label_). Cette moyenne calculée sera notre _template_."]},{"cell_type":"code","execution_count":null,"id":"2a21bd35","metadata":{"id":"2a21bd35"},"outputs":[],"source":["def compute_templates(dataset):\n"," # Get the number of classes\n"," nb_classes = len(set(dataset.targets.numpy()))\n"," print(f\"Found {nb_classes} classes in the dataset of {len(dataset.targets)} samples\")\n"," templates = []\n"," for c in range(nb_classes):\n"," indices = dataset.targets == c\n"," images = dataset.data[indices].float()\n"," template = images.mean(axis=0) / 255\n"," templates.append(template.numpy())\n"," return templates"]},{"cell_type":"markdown","id":"f5157007","metadata":{"id":"f5157007"},"source":["Utilisons cette fonction pour calculer les _templates_ sur le jeu d'apprentissage de MNIST."]},{"cell_type":"code","execution_count":null,"id":"bee737d1","metadata":{"id":"bee737d1"},"outputs":[],"source":["train_set = torchvision.datasets.MNIST(DATADIR, train=True, transform=None, download=True)\n","test_set = torchvision.datasets.MNIST(DATADIR, train=False, transform=None)\n","templates = compute_templates(train_set)\n","print(f\"Computed {len(templates)} templates\")"]},{"cell_type":"markdown","id":"103b07c7","metadata":{"id":"103b07c7"},"source":["Visualisons les templates obtenus : "]},{"cell_type":"code","execution_count":null,"id":"2ad4bf52","metadata":{"id":"2ad4bf52"},"outputs":[],"source":["plt.figure(figsize=(20,8))\n","plt.imshow(1 - np.concatenate(templates, axis=1), cmap=\"gray\")\n","plt.axis(\"off\")\n","plt.show()"]},{"cell_type":"markdown","id":"3ca7fb59","metadata":{"id":"3ca7fb59"},"source":["La fonction suivante prend en entrée un jeu de test ainsi que les _templates_, et calcule la corrélation entre une image et les 10 _templates_. Ensuite, le _template_ qui a produit la plus forte réponse (c'est-à-dire qu'un maximum de pixels ont été en adéquation avec le _template_) donnera la classe prédite par le modèle."]},{"cell_type":"code","execution_count":null,"id":"4c54942f","metadata":{"id":"4c54942f"},"outputs":[],"source":["def template_matching(dataset, templates):\n"," print(f\"Classifying {len(dataset)} images\")\n"," predictions, labels = [], []\n"," for image, label in dataset:\n"," labels.append(label)\n"," image = torch.from_numpy(np.array(image)).float()/255\n"," correlations = []\n"," for m, template in enumerate(templates):\n"," correlation = (image*template).sum()\n"," correlations.append(correlation)\n"," prediction = np.argmax(correlations)\n"," predictions.append(prediction)\n"," return predictions, labels"]},{"cell_type":"markdown","id":"99ca507b","metadata":{"id":"99ca507b"},"source":["Le jeu d'entrainement (ou le jeu d'apprentissage, le _training set_) ayant servi à construire les templates, on va utiliser le jeu de test pour l'évaluation :"]},{"cell_type":"code","execution_count":null,"id":"fbcfc481","metadata":{"id":"fbcfc481"},"outputs":[],"source":["predictions, labels = template_matching(test_set, templates)\n","test_accuracy = compute_accuracy(predictions, labels)\n","print(f\"Test accuracy {test_accuracy:.2f} %\")"]},{"cell_type":"markdown","id":"62b676af","metadata":{"id":"62b676af"},"source":["Ce nouveau classifier est capable d'assigner une des dix classes possibles à une image et obtient une performance de 63 % (soit 6 fois mieux que s'il répondait au hasard, qui serait de 1/10 puisqu'il y a 10 classes).\n","\n","On peut faire mieux en utisant un réseau de neurones, qui va optimiser proprement les poids $w_i$ pour maximiser la performance.\n","\n","Dans la suite, nous allons voir un réseau de type perceptron à une seule couche, puis un réseau convolutif de type LeNet5 à 5 couches."]},{"cell_type":"markdown","id":"5dfcb620","metadata":{"id":"5dfcb620"},"source":["# Implémentation d'un réseau de neurones avec PyTorch\n","\n","Dans cette section, nous allons implémenter un réseau de neurones artificiels.\n","\n","Chaque neurone effectue l'opération suivante :\n","\n","$$f(x ; w, b) = w^{\\top}x + b = \\sum_{i=1}^{784} w_i x_i + b,$$\n","\n","où $x$ représente l'image de 784 pixels, $w \\in \\mathbb{R}^{784}$ un vecteur de poids de taille 784, et $b \\in \\mathbb{R}$ un biais (un scalaire).\n","\n","On construit un réseau avec une couche contenant 10 neurones : chaque neurone est responsable de prédire une classe. Comme auparavant, la classe qui obtient le score le plus élevé déterminera la classe prédite."]},{"cell_type":"markdown","id":"b6c4c8c1","metadata":{"id":"b6c4c8c1"},"source":["Pour entrainer un réseau de neurones, on parcourt le jeu d'entrainement par bloc de 100 exemples (appelé un _minibatch_) à l'aide d'un _loader_ qui sélectionne aléatoirement les images.\n","\n","Les images sont également normalisées à l'aide d'une normalisation centrée réduite qui transforme les images pour avoir une moyenne de 0 et une variance de 1 :\n","\n","$$\\tilde{x} = \\frac{x - \\mu}{\\sigma},$$\n","\n","où $\\mu$ est l'image moyenne et $\\sigma$ l'écart type. Cette normalisation facilite l'apprentissage du réseau de neurones."]},{"cell_type":"code","execution_count":null,"id":"ccdb508b","metadata":{"id":"ccdb508b"},"outputs":[],"source":["batch_size = 100\n","\n","# Normalization\n","transform = torchvision.transforms.Compose([\n"," torchvision.transforms.ToTensor(), \n"," torchvision.transforms.Normalize((0.1307,), (0.3081,))\n","])\n","\n","# Data\n","train_set = torchvision.datasets.MNIST(DATADIR, transform=transform, train=True, download=True)\n","test_set = torchvision.datasets.MNIST(DATADIR, transform=transform, train=False)\n","\n","# Loaders\n","train_loader = torch.utils.data.DataLoader(train_set, batch_size=batch_size, shuffle=True)\n","test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size)"]},{"cell_type":"markdown","id":"0f7e18b6","metadata":{"id":"0f7e18b6"},"source":["La cellule suivante définit un réseau de neurone qui prend en entrée une image de taille `28 x 28` et sort 10 scores, un pour chaque classe :"]},{"cell_type":"code","execution_count":null,"id":"3f79c138","metadata":{"id":"3f79c138"},"outputs":[],"source":["class Perceptron(nn.Module):\n"," def __init__(self):\n"," super(type(self), self).__init__()\n"," self.fc = nn.Linear(28*28, 10)\n","\n"," def forward(self, x):\n"," x = x.view(len(x), -1)\n"," x = self.fc(x)\n"," return x"]},{"cell_type":"markdown","id":"e7ae2d6e","metadata":{"id":"e7ae2d6e"},"source":["La fonction suivante effectue une _epoch_ d'apprentissage, c'est-à-dire que l'intégralité des données d'entrainement est parcourue par blocs de 100 (le `batch_size`) et le modèle est mis à jour à chaque _batch_."]},{"cell_type":"code","execution_count":null,"id":"0bf4ab45","metadata":{"id":"0bf4ab45"},"outputs":[],"source":["def train(net, loader, criterion, optimizer):\n"," device = \"cuda\" if next(net.parameters()).is_cuda else \"cpu\"\n"," net.train()\n"," total_loss = 0\n"," for i, (batch, target) in enumerate(loader):\n"," batch = batch.to(device)\n"," target = target.to(device)\n"," output = net(batch)\n"," loss = criterion(output, target)\n"," optimizer.zero_grad()\n"," loss.backward()\n"," optimizer.step()\n"," total_loss += loss.item()\n","\n"," return total_loss / len(loader)"]},{"cell_type":"markdown","id":"e7220508","metadata":{"id":"e7220508"},"source":["La fonction suivante évalue la performance du réseau de neurones (similaire à la fonction `compute_accuracy()` plus haut)."]},{"cell_type":"code","execution_count":null,"id":"0a724f51","metadata":{"id":"0a724f51"},"outputs":[],"source":["def test(net, loader):\n"," device = \"cuda\" if next(net.parameters()).is_cuda else \"cpu\"\n"," net.eval()\n"," n_correct = 0\n"," with torch.no_grad():\n"," for i, (batch, target) in enumerate(loader):\n"," batch = batch.to(device)\n"," target = target.to(device)\n"," output = net(batch)\n"," _, pred = torch.max(output, 1)\n"," correct = torch.eq(target, pred).sum()\n"," n_correct += correct\n"," return 100*n_correct/len(loader.dataset)"]},{"cell_type":"markdown","id":"5078bdb0","metadata":{"id":"5078bdb0"},"source":["On crée maintenant :\n"," \n","- le modèle `model`,\n","- une vitesse d'apprentissage `learning_rate`,\n","- un critère `criterion` utilisé pour calculer le _loss_,\n","- un opimiseur `optimizer`, qui effectue la descente de gradient."]},{"cell_type":"code","execution_count":null,"id":"db699c89","metadata":{"id":"db699c89"},"outputs":[],"source":["learning_rate = 0.01\n","model = Perceptron()\n","model.to(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n","criterion = nn.CrossEntropyLoss()\n","optimizer = optim.SGD(model.parameters(), lr=learning_rate)"]},{"cell_type":"markdown","id":"6108caca","metadata":{"id":"6108caca"},"source":["On peut donc maintenant entrainer. Ici, on va parcourir 5 fois le jeu d'apprentissage (donc 5 _epochs_), et la performance du réseau de neurones est évaluer à la fin de chaque passe."]},{"cell_type":"code","execution_count":null,"id":"9ae48b68","metadata":{"id":"9ae48b68"},"outputs":[],"source":["nb_epochs = 5\n","data = []\n","for epoch in range(nb_epochs):\n"," tic = time.perf_counter()\n"," train_loss = train(model, train_loader, criterion, optimizer)\n"," accuracy = test(model, test_loader)\n"," toc = time.perf_counter()\n"," data.append((epoch, train_loss, accuracy))\n"," print(f\"epoch {epoch} loss {train_loss:.5f} accuracy {accuracy:.2f} took {toc-tic:.2f} s\")"]},{"cell_type":"markdown","id":"cb1c90cb","metadata":{"id":"cb1c90cb"},"source":["Ce modèle atteint une accuracy de 92 % (à comparer aux 61 % du _template matching_).\n","\n","Une fois l'apprentissage terminé, on peut regarder à quoi ressemblent les poids du réseau de neurones :"]},{"cell_type":"code","execution_count":null,"id":"cf42c51b","metadata":{"id":"cf42c51b"},"outputs":[],"source":["def display_weights(net):\n"," weights = model.fc.weight.view(-1, 28, 28).unsqueeze(1).detach().to(\"cpu\")\n"," grid = torchvision.utils.make_grid(weights, nrow=len(weights), pad_value=weights.min())[0]\n"," plt.figure(figsize=(20,8))\n"," plt.imshow(grid)\n"," plt.axis(\"off\")\n"," plt.show()"]},{"cell_type":"code","execution_count":null,"id":"960cad29","metadata":{"id":"960cad29"},"outputs":[],"source":["display_weights(model)"]},{"cell_type":"markdown","id":"0f3bd552","metadata":{"id":"0f3bd552"},"source":["Le rendu visuel produit une image comme celle-ci :\n","\n","\n","\n","\n","\n","
\n","\n","- La première image correspond aux poids pour la classe 0, la seconde pour la classe 1...\n","- Les couleurs chaudes (orange, rouge) correspondent à des poids positifs, tandis que les couleurs froides à des poids négatifs, le vert étant des poids proches de zéros"]},{"cell_type":"markdown","id":"1a8daf9f","metadata":{"id":"1a8daf9f"},"source":["# Implémentation d'un réseau convolutif avec PyTorch\n","\n","Pour traiter des images, on utilise en générale des couches de \"neurones de convolution\", et le réseau est appelé [réseau convolutif](https://fr.wikipedia.org/wiki/Réseau_neuronal_convolutif). Au lieu de traiter l'intégralité du signal d'entrée, chaque neurone convolutif \"regarde\" une petite partie de l'image.\n","\n","Un des premiers réseaux convolutifs a été proposé par [Yann LeCun et al. en 1998](http://yann.lecun.com/exdb/publis/pdf/lecun-01a.pdf), et a l'architecture suivante :\n","\n","\n","\n","\n","\n","
\n","\n","La première partie du réseau (de `C1` jusqu'à `S4`) est une succession de convolution et de pooling (couche d'aggrégation pour réduire la taille du signal), et la deuxième partie (`C5` et `F6`) est un perceptron multi-couche."]},{"cell_type":"markdown","id":"baca4cb9","metadata":{"id":"baca4cb9"},"source":["La cellule suivante définit un réseau convolutif, de type LeNet (architecture un peu différente de la structure sur l'image ci-dessus)."]},{"cell_type":"code","execution_count":null,"id":"f1ce813d","metadata":{"id":"f1ce813d"},"outputs":[],"source":["class LeNet5(nn.Module):\n"," def __init__(self):\n"," super(type(self), self).__init__()\n"," self.conv1 = nn.Conv2d(1, 10, 5, 1, 0)\n"," self.conv2 = nn.Conv2d(10, 20, 5, 1, 0)\n"," self.fc1 = nn.Linear(4*4*20, 32)\n"," self.fc2 = nn.Linear(32, 10)\n","\n"," def forward(self, x):\n"," x = F.max_pool2d(F.relu(self.conv1(x)), 2, 2)\n"," x = F.max_pool2d(F.relu(self.conv2(x)), 2, 2)\n"," x = x.view(x.size(0), -1)\n"," x = F.relu(self.fc1(x))\n"," x = self.fc2(x)\n"," return x"]},{"cell_type":"code","execution_count":null,"id":"3f9e2fa4","metadata":{"id":"3f9e2fa4"},"outputs":[],"source":["learning_rate = 0.1\n","model = LeNet5()\n","model.to(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n","criterion = nn.CrossEntropyLoss()\n","optimizer = optim.SGD(model.parameters(), lr=learning_rate)"]},{"cell_type":"code","execution_count":null,"id":"db145998","metadata":{"id":"db145998"},"outputs":[],"source":["nb_epochs = 2\n","data = []\n","for epoch in range(nb_epochs):\n"," tic = time.perf_counter()\n"," train_loss = train(model, train_loader, criterion, optimizer)\n"," accuracy = test(model, test_loader)\n"," toc = time.perf_counter()\n"," data.append((epoch, train_loss, accuracy))\n"," print(f\"epoch {epoch} loss {train_loss:.5f} accuracy {accuracy:.2f} took {toc-tic:.2f} s\")"]}],"metadata":{"kernelspec":{"display_name":"Python 3 (ipykernel)","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.9.15"},"colab":{"provenance":[]}},"nbformat":4,"nbformat_minor":5}