Alai

Introduction

« Construire un modèle d’apprentissage profond en quelques minutes ? Il faudra des heures pour l’entraîner ! Je n’ai même pas une assez bonne machine. » J’ai entendu cela d’innombrables fois de la part de data scientists en herbe qui hésitent à construire des modèles d’apprentissage profond sur leurs propres machines.

Vous n’avez pas besoin de travailler pour Google ou d’autres grandes entreprises technologiques pour travailler sur des ensembles de données d’apprentissage profond ! Il est tout à fait possible de construire votre propre réseau neuronal à partir de la base en quelques minutes sans avoir besoin de louer les serveurs de Google. Les étudiants de Fast.ai ont conçu un modèle sur le jeu de données Imagenet en 18 minutes – et je présenterai quelque chose de similaire dans cet article.

L’apprentissage profond est un vaste domaine, nous allons donc restreindre un peu notre objectif et relever le défi de résoudre un projet de classification d’images. De plus, nous utiliserons une architecture d’apprentissage profond très simple pour atteindre un score de précision assez impressionnant.

Vous pouvez considérer le code Python que nous verrons dans cet article comme une référence pour la construction de modèles de classification d’images. Une fois que vous aurez bien saisi le concept, allez-y et jouez avec le code, participez à des compétitions et grimpez dans le classement !

Si vous êtes nouveau dans l’apprentissage profond et que vous êtes fasciné par le domaine de la vision par ordinateur (qui ne l’est pas ? !), consultez le cours  » Computer Vision using Deep Learning « . C’est une introduction complète à ce merveilleux domaine et vous mettra en place pour ce qui est inévitablement un énorme marché du travail dans un proche avenir.

Projet d’application de la classification des images

Plus de 25% de l’ensemble des revenus du commerce électronique est attribué aux vêtements & accessoires. Un problème majeur auquel ils sont confrontés est de catégoriser ces vêtements à partir des seules images surtout lorsque les catégories fournies par les marques sont incohérentes. Cela pose un problème intéressant de vision par ordinateur qui a attiré l’attention de plusieurs chercheurs en apprentissage profond.

Fashion MNIST est un remplacement drop-in pour le très bien connu, l’apprentissage machine hello world – MNIST dataset qui peut être vérifié à ‘Identifier les chiffres’ problème pratique. Au lieu de chiffres, les images montrent un type de vêtement, par exemple un T-shirt, un pantalon, un sac, etc. Le jeu de données utilisé dans ce problème a été créé par Zalando Research.

Pratique maintenant

Table des matières

1. Qu’est-ce que la classification d’images et ses cas d’utilisation
2. Mise en place de la structure de nos données d’images
3. Décomposer le processus de construction du modèle. Processus
4. Mise en place de l’énoncé du problème et compréhension des données
5. Étapes de la construction du modèle de classification d’images
6. Relever un autre défi

Qu’est-ce que la classification d’images ?

Considérez l’image ci-dessous :

Vous l’aurez instantanément reconnue – c’est une voiture (chic). Prenez un peu de recul et analysez comment vous êtes arrivé à cette conclusion – on vous a montré une image et vous avez classé la classe à laquelle elle appartenait (une voiture, dans ce cas). Et c’est, en un mot, ce qu’est la classification des images.

Il existe potentiellement n nombre de catégories dans lesquelles une image donnée peut être classée. Vérifier et classer manuellement les images est un processus très fastidieux. La tâche devient presque impossible lorsque nous sommes confrontés à un nombre massif d’images, disons 10 000 ou même 100 000. Quelle serait l’utilité si nous pouvions automatiser l’ensemble de ce processus et étiqueter rapidement les images selon leur classe correspondante ?

Les voitures autonomes sont un excellent exemple pour comprendre où la classification des images est utilisée dans le monde réel. Pour permettre la conduite autonome, nous pouvons construire un modèle de classification d’images qui reconnaît divers objets, tels que des véhicules, des personnes, des objets en mouvement, etc. sur la route. Nous verrons quelques autres cas d’utilisation plus loin dans cet article, mais il existe de nombreuses autres applications autour de nous. Utilisez la section des commentaires en dessous de l’article pour me faire savoir quels cas d’utilisation potentiels vous pouvez trouver !

Maintenant que nous avons une poignée sur notre sujet, plongeons dans la façon dont un modèle de classification d’image est construit, quels sont les prérequis pour cela, et comment il peut être mis en œuvre en Python.

Mise en place de la structure de nos données d’image

Nos données doivent être dans un format particulier afin de résoudre un problème de classification d’image. Nous verrons cela en action dans quelques sections mais gardez juste ces points à l’esprit jusqu’à ce que nous y arrivions.

Vous devriez avoir 2 dossiers, un pour l’ensemble d’entraînement et l’autre pour l’ensemble de test. Dans l’ensemble de formation, vous aurez un fichier .csv et un dossier d’images :

• Le fichier .csv contient les noms de toutes les images de formation et leurs étiquettes vraies correspondantes
• Le dossier d’images contient toutes les images de formation.

Le fichier .csv de notre ensemble de test est différent de celui présent dans l’ensemble de formation. Ce fichier .csv de l’ensemble de test contient les noms de toutes les images de test, mais elles n’ont pas d’étiquettes correspondantes. Pouvez-vous deviner pourquoi ? Notre modèle sera entraîné sur les images présentes dans l’ensemble d’entraînement et les prédictions d’étiquettes se produiront sur les images de l’ensemble de test

Si vos données ne sont pas dans le format décrit ci-dessus, vous devrez les convertir en conséquence (sinon les prédictions seront faussées et assez inutiles).

Décomposer le processus de construction du modèle

Avant de plonger profondément dans le code Python, prenons un moment pour comprendre comment un modèle de classification d’images est généralement conçu. Nous pouvons diviser grossièrement ce processus en 4 étapes. Chaque étape nécessite un certain temps d’exécution :

1. Chargement et prétraitement des données – 30% de temps
2. Définition de l’architecture du modèle – 10% de temps
3. Entraînement du modèle – 50% de temps
4. Estimation des performances – 10% de temps

Laissons-moi expliquer chacune des étapes ci-dessus un peu plus en détail. Cette section est cruciale car tous les modèles ne sont pas construits du premier coup. Vous devrez revenir en arrière après chaque itération, affiner vos étapes et l’exécuter à nouveau. Avoir une solide compréhension des concepts sous-jacents contribuera grandement à accélérer l’ensemble du processus.

Etape 1 : Chargement et prétraitement des données

Les données sont de l’or en ce qui concerne les modèles d’apprentissage profond. Votre modèle de classification d’images a beaucoup plus de chances d’être performant si vous disposez d’une bonne quantité d’images dans l’ensemble d’entraînement. De plus, la forme des données varie en fonction de l’architecture/du framework que nous utilisons.

D’où l’étape critique du prétraitement des données (l’étape éternellement importante dans tout projet). Je recommande vivement de parcourir le document ‘Basics of Image Processing in Python’ pour mieux comprendre comment le prétraitement fonctionne avec les données d’image.

Mais nous ne sommes pas encore tout à fait arrivés. Afin de voir comment notre modèle se comporte sur des données non vues (et avant de l’exposer à l’ensemble de test), nous devons créer un ensemble de validation. Cela se fait en partitionnant les données de l’ensemble d’entraînement.

En bref, nous entraînons le modèle sur les données d’entraînement et le validons sur les données de validation. Une fois que nous sommes satisfaits de la performance du modèle sur l’ensemble de validation, nous pouvons l’utiliser pour faire des prédictions sur les données de test.

Temps nécessaire pour cette étape : Nous avons besoin d’environ 2 à 3 minutes pour cette tâche.

Étape 2 : Définition de l’architecture du modèle

C’est une autre étape cruciale dans notre processus de construction de modèles d’apprentissage profond. Nous devons définir à quoi ressemblera notre modèle et cela nécessite de répondre à des questions telles que :

• Combien de couches convolutives voulons-nous ?
• Quelle doit être la fonction d’activation de chaque couche ?
• Combien d’unités cachées doit avoir chaque couche ?

Et bien d’autres encore. Ce sont essentiellement les hyperparamètres du modèle qui jouent un rôle MASSIF pour décider de la qualité des prédictions.

Comment décidons-nous de ces valeurs ? Excellente question ! Une bonne idée est de choisir ces valeurs en fonction des recherches/études existantes. Une autre idée est de continuer à expérimenter avec les valeurs jusqu’à ce que vous trouviez la meilleure correspondance, mais cela peut être un processus assez long.

Temps nécessaire pour cette étape : Cela devrait prendre environ 1 minute pour définir l’architecture du modèle.

Étape 3 : Entraînement du modèle

Pour entraîner le modèle, nous avons besoin :

• Des images d’entraînement et leurs étiquettes vraies correspondantes
• Des images de validation et leurs étiquettes vraies correspondantes (nous utilisons ces étiquettes uniquement pour valider le modèle et non pendant la phase d’entraînement)

Nous définissons également le nombre d’époques dans cette étape. Pour commencer, nous allons exécuter le modèle pendant 10 époques (vous pouvez changer le nombre d’époques plus tard).

Temps nécessaire pour cette étape : Comme l’entraînement nécessite que le modèle apprenne des structures, nous avons besoin d’environ 5 minutes pour passer par cette étape.

Et maintenant, il est temps de faire des prédictions !

Etape 4 : Estimation des performances du modèle

Enfin, nous chargeons les données de test (images) et passons par l’étape de prétraitement ici aussi. Nous prédisons ensuite les classes pour ces images en utilisant le modèle entraîné.

Temps requis pour cette étape : ~ 1 minute.

Mise en place de l’énoncé du problème et compréhension des données

Nous allons relever un défi vraiment cool pour comprendre la classification des images. Nous devons construire un modèle capable de classer un ensemble donné d’images en fonction du vêtement (chemise, pantalon, chaussures, chaussettes, etc.). C’est en fait un problème auquel sont confrontés de nombreux détaillants de commerce électronique, ce qui en fait un problème de vision par ordinateur encore plus intéressant.

Ce défi s’appelle  » Identifier les vêtements  » et est l’un des problèmes pratiques que nous avons sur notre plateforme DataHack. Vous devrez vous inscrire et télécharger le jeu de données à partir du lien ci-dessus.

Nous avons un total de 70 000 images (dimension 28 x 28), dont 60 000 proviennent du jeu d’entraînement et 10 000 du jeu de test. Les images d’entraînement sont pré-étiquetées selon le type de vêtement avec 10 classes au total. Les images de test ne sont, bien entendu, pas étiquetées. Le défi consiste à identifier le type de vêtement présent dans toutes les images de test.

Nous construirons notre modèle sur Google Colab puisqu’il fournit un GPU gratuit pour entraîner nos modèles.

Étapes de construction de notre modèle

Il est temps d’enflammer vos compétences en Python et de vous salir les mains. Nous en sommes enfin à la partie mise en œuvre de notre apprentissage !

1. Configuration de Google Colab
2. Importation des bibliothèques
3. Chargement et prétraitement des données – (3 mins)
4. Création d’un ensemble de validation

.

5. Définir la structure du modèle – (1 min)
6. Entraîner le modèle – (5 min)
7. Faire des prédictions – (1 min)

Regardons chaque étape en détail.

Etape 1 : Configuration de Google Colab

Puisque nous importons nos données à partir d’un lien Google Drive, nous allons devoir ajouter quelques lignes de code dans notre notebook Google Colab. Créez un nouveau notebook Python 3 et écrivez les blocs de code suivants :

!pip install PyDrive

Cela va installer PyDrive. Maintenant, nous allons importer quelques bibliothèques requises:

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

Puis, nous allons créer une variable drive pour accéder à Google Drive:

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

Pour télécharger le jeu de données, nous allons utiliser l’ID du fichier téléchargé sur Google Drive:

download = drive.CreateFile({'id': '1BZOv422XJvxFUnGh-0xVeSvgFgqVY45q'})

Remplacer le ‘id’ dans le code ci-dessus avec l’ID de votre fichier. Maintenant, nous allons télécharger ce fichier et le décompresser :

download.GetContentFile('train_LbELtWX.zip')!unzip train_LbELtWX.zip

Vous devez exécuter ces blocs de code chaque fois que vous démarrez votre notebook.

Etape 2 : Importez les bibliothèques dont nous aurons besoin pendant notre phase de construction de modèle.

import kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

Etape 3 : Rappelez-vous les étapes de prétraitement dont nous avons parlé précédemment. Nous allons les utiliser ici après avoir chargé les données.

train = pd.read_csv('train.csv')

Puis, nous allons lire toutes les images d’entraînement, les stocker dans une liste, et enfin convertir cette liste en un tableau numpy.

# We have grayscale images, so while loading the images we will keep grayscale=True, if you have RGB images, you should set grayscale as Falsetrain_image = for i in tqdm(range(train.shape)): img = image.load_img('train/'+train.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

Comme il s’agit d’un problème de classification multi-classes (10 classes), nous allons coder en un coup la variable cible.

y=train.valuesy = to_categorical(y)

Etape 4 : créer un ensemble de validation à partir des données d’entraînement.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

Etape 5 : définir la structure du modèle.

Nous allons créer une architecture simple avec 2 couches convolutives, une couche cachée dense et une couche de sortie.

model = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

Puis, nous allons compiler le modèle que nous avons créé.

model.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

Étape 6 : Entraînement du modèle.

Dans cette étape, nous allons entraîner le modèle sur les images de l’ensemble d’entraînement et le valider en utilisant, vous l’avez deviné, l’ensemble de validation.

model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

Etape 7 : Faire des prédictions !

Dans un premier temps, nous allons suivre les étapes que nous avons effectuées lors du traitement des données d’entraînement. Chargez les images de test et prédisez leurs classes à l’aide de la fonction model.predict_classes().

download = drive.CreateFile({'id': '1KuyWGFEpj7Fr2DgBsW8qsWvjqEzfoJBY'})download.GetContentFile('test_ScVgIM0.zip')!unzip test_ScVgIM0.zip

Importons le fichier de test :

test = pd.read_csv('test.csv')

Maintenant, nous allons lire et stocker toutes les images de test :

test_image = for i in tqdm(range(test.shape)): img = image.load_img('test/'+test.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

# making predictionsprediction = model.predict_classes(test)

Nous allons également créer un fichier de soumission à télécharger sur la page de la plateforme DataHack (pour voir comment nos résultats se classent sur le leaderboard).

download = drive.CreateFile({'id': '1z4QXy7WravpSj-S4Cs9Fk8ZNaX-qh5HF'})download.GetContentFile('sample_submission_I5njJSF.csv')

# creating submission filesample = pd.read_csv('sample_submission_I5njJSF.csv')sample = predictionsample.to_csv('sample_cnn.csv', header=True, index=False)

Téléchargez ce fichier sample_cnn.csv et téléchargez-le sur la page du concours pour générer vos résultats et vérifier votre classement au tableau des leaders. Cela vous donnera une solution de référence pour vous permettre de commencer à résoudre n’importe quel problème de classification d’images !

Vous pouvez essayer les techniques de réglage des hyperparamètres et de régularisation pour améliorer encore les performances de votre modèle. Je vous écnourage de consulter cet article pour comprendre cette étape de réglage fin de manière beaucoup plus détaillée – ‘Un tutoriel complet pour apprendre les réseaux neuronaux convolutifs à partir de zéro’.

Relever un défi différent

Testons notre apprentissage sur un ensemble de données différent. Nous allons résoudre le problème pratique  » Identifier les chiffres  » dans cette section. Allez-y et téléchargez le jeu de données. Avant de continuer, essayez de le résoudre par vous-même. Vous avez déjà les outils pour le résoudre – il vous suffit de les appliquer ! Revenez ici pour vérifier vos résultats ou si vous êtes bloqué à un moment donné.

Dans ce défi, nous devons identifier le chiffre dans une image donnée. Nous avons un total de 70 000 images – 49 000 étiquetées dans l’ensemble d’entraînement et les 21 000 restantes dans l’ensemble de test (les images de test ne sont pas étiquetées). Nous devons identifier/prédire la classe de ces images non étiquetées.

Prêts à commencer ? Génial ! Créez un nouveau notebook Python 3 et exécutez le code suivant :

# Setting up Colab!pip install PyDrive

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

# Replace the id and filename in the below codesdownload = drive.CreateFile({'id': '1ZCzHDAfwgLdQke_GNnHp_4OheRRtNPs-'})download.GetContentFile('Train_UQcUa52.zip')!unzip Train_UQcUa52.zip

# Importing librariesimport kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

train = pd.read_csv('train.csv')

# Reading the training imagestrain_image = for i in tqdm(range(train.shape)): img = image.load_img('Images/train/'+train, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

# Creating the target variabley=train.valuesy = to_categorical(y)

# Creating validation setX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

# Define the model structuremodel = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

# Compile the modelmodel.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

# Training the modelmodel.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

download = drive.CreateFile({'id': '1zHJR6yiI06ao-UAh_LXZQRIOzBO3sNDq'})download.GetContentFile('Test_fCbTej3.csv')

test_file = pd.read_csv('Test_fCbTej3.csv')

test_image = for i in tqdm(range(test_file.shape)): img = image.load_img('Images/test/'+test_file, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

prediction = model.predict_classes(test)

download = drive.CreateFile({'id': '1nRz5bD7ReGrdinpdFcHVIEyjqtPGPyHx'})download.GetContentFile('Sample_Submission_lxuyBuB.csv')

sample = pd.read_csv('Sample_Submission_lxuyBuB.csv')sample = test_filesample = predictionsample.to_csv('sample.csv', header=True, index=False)

Soumettez ce fichier sur la page du problème pratique pour obtenir un nombre de précision assez décent. C’est un bon début mais il est toujours possible de s’améliorer. Continuez à jouer avec les valeurs des hyperparamètres et voyez si vous pouvez améliorer notre modèle de base.

Notes de fin

Qui a dit que les modèles d’apprentissage profond nécessitaient des heures ou des jours pour être formés. Mon but ici était de montrer que vous pouvez arriver à un modèle d’apprentissage profond assez décent en deux temps trois mouvements. Vous devriez relever des défis similaires et essayer de les coder de votre côté également. Il n’y a rien de tel que d’apprendre en faisant !

Les meilleurs scientifiques et analystes de données ont ces codes prêts avant même qu’un Hackathon ne commence. Ils utilisent ces codes pour faire les premières soumissions avant de plonger dans une analyse détaillée. Une fois qu’ils ont une solution de référence, ils commencent à améliorer leur modèle en utilisant différentes techniques.