0

[Beta] Du deep learning avec CreateML et Xcode 10

Ce tutoriel ne fonctionne plus avec Xcode 11.

 

Salut salut tout le monde ! Alors aujourd’hui on va voir comment se créer son propre classeur d’image basé sur du deep learning grâce à la bêta d’Xcode 10 (sur macOS Mojave). Eh oui, une des nouveautés dans CoreML c’est ce petit outil qui permet de construire ses propres modèles directement depuis un playground qui s’appelle astucieusement CreateML. Je vous invite donc à télécharger les versions des logiciels concernés car si vous n’êtes pas sur la bêta vous ne pourrez pas l’essayer.

Comment ça marche ?

Un des exercices très difficiles auquel sont confrontés les appareils informatiques est qu’il doivent pouvoir voir ce qui se trouve sur une image. Là où un être humain n’a pas de mal à différencier un hamburger d’une pizza quand il en voit une, pour un ordinateur il ne s’agit que d’une suite de pixels colorés qui n’ont aucun sens. Il faut apprendre à l’ordinateur à quoi ressemble un burger ou une pizza pour qu’ils puissent les différencier, seulement il n’est pas possible d’en définir tous les critères.

Prenons le cas du hamburger. On pourrait apprendre à un algorithme qu’il est constitué d’au moins un steak entre deux tranches de pain.

Ok, pas de problème, dès que l’algorithme détectera cette combinaison d’ingrédients dans cet ordre, il pourra en déduire qu’il s’agit bien d’un burger. Mais tous les burgers ne sont pas tous composés de la même façon, et la détection de ces ingrédients peut s’avérer très délicate sur une image qu’il n’a jamais vu auparavant.

Si on lui présente cette image, il ne pourra pas trouver de hamburger dessus car il est ouvert, et il y a tout un tas de parasites venant brouiller son analyse (frites, sauces, une main, une assiette, etc…). Il faudrait alors prévoir tous les cas possible de présentation d’un hamburger, ce qui n’est clairement pas possible.

La méthode la plus simple pour parvenir à ceci est de faire passer une multitude d’images dans un réseau de neurones qui va à force de voir passer des burgers va lui-même déterminer quels sont les critères de reconnaissance d’un burger, parmi une multitude d’options mathématiques auxquelles nous n’aurions pas pensé. Il sera donc, si on lui présente suffisamment d’images, capable de détecter un burger même sur une image et une “configuration” qu’il n’a jamais rencontré.

Télécharger des modèles d’images

Je ne vais pas m’attarder sur les explications du machine learning, du deep learning, de CoreML, de Metal et autres joyeuseries aujourd’hui, nous aurons certainement l’occasion d’y dédier plus de temps ! Concrètement nous allons construire un intelligence artificielle capable de reconnaitre un objet sur une image, en quelques lignes de code.

Tout d’abord, il nous faut des images des objets que nous voulons apprendre à notre IA. Je vous ait à cet effet préparé un petit set d’images d’hamburgers (on reste dans le thème) et de pizzas trouvés sur ImageNet que je vous invite à télécharger.

Télécharger “Training Images CreateML Hamburger / Pizza” Data.zip – Téléchargé 89 fois – 22 MB

Une fois décompressé, vous devriez trouver dans le dossier Data les sous dossiers hamburger et pizza contenant chacun environ 80 images.

Vous pouvez créer vos propres sets d’images grâce à mon application ImageNet Downloader.

C’est parti

Allons-y ! Ouvrons un nouveau playground vide (blank) pour mac dans Xcode 10. Nous allons ensuite entrer ce code dans le playground :

1
2
3
4
import CreateMLUI

let builder = MLImageClassifierBuilder()
builder.showInLiveView()

Cela permet d’afficher l’interface créée par Apple pour CreateML. Petite subtilité par rapport aux Playgrounds sur Xcode 9, il faut le lancer manuellement en cliquant sur le petit bouton play en bleu par dessus le dernier numéro de ligne. Il est également nécessaire d’afficher l’Assistant d’éditeur via le bouton dédié en haut à droite du playground.

Exécuter le script
2
Assitant d'édition

 

On obtient dans la vue à droite le créateur de modèle. Si on clique sur la petite flèche à droite de ImageClassifier, on peut afficher les paramètres d’apprentissage.

  • Max iterations : le nombre de fois maximum où l’algorithme analysera les données
  • Training Data : dossier contenant des dossiers d’images à analyser pour l’apprentissage (notre dossier data)
  • Validation Data : dossier à la même structure que Training Data mais contenant des images inconnues pour la validation du bon fonctionnement de l’algorithme
  • Augmentation : modification de l’image d’origine pour la tester dans plusieurs configurations possibles

Voici ce que produisent les différentes augmentations proposées. Au plus on choisit d’options, au plus il y aura d’images à tester, donc plus long ce sera à faire. Il est à noter qu’il n’est pas nécessaire de tout cocher pour chaque cas. Je vous réfère à la page Apple Developper parlant de l’optimisation de la précision des modèles. Pour notre exemple, nous allons conserver les réglages de base.

Entrainer notre modèle

Pour entrainer notre modèle, il suffit de glisser-déposer le dossier data dans l’emplacement prévu à cet effet sous la fenêtre de paramétrage. Dès que le dossier est déposé, l’analyse commence. Selon la puissance de votre Mac (surtout de votre carte graphique) l’analyse sera plus ou moins longue. On peut avoir un détail de l’exécution en temps réel simplement en ouvrant la console du playground.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
Extracting image features from full data set.
Analyzing and extracting image features.
+------------------+--------------+------------------+
| Images Processed | Elapsed Time | Percent Complete |
+------------------+--------------+------------------+
| 1                | 1.73s        | 0.5%             |
| 2                | 1.88s        | 1%               |
| 3                | 2.02s        | 1.75%            |
| 4                | 2.15s        | 2.25%            |
| 5                | 2.34s        | 3%               |
| 10               | 3.15s        | 6%               |
| 25               | 5.32s        | 15.25%           |
| 50               | 8.88s        | 30.75%           |
| 75               | 12.35s       | 46.25%           |
| 100              | 15.82s       | 61.5%            |
| 125              | 19.46s       | 77%              |
| 150              | 23.46s       | 92.5%            |
| 162              | 25.23s       | 100%             |
+------------------+--------------+------------------+
Automatically generating validation set from 10% of the data.
Beginning model training on processed features.
Calibrating solver; this may take some time.
+-----------+--------------+-------------------+---------------------+
| Iteration | Elapsed Time | Training-accuracy | Validation-accuracy |
+-----------+--------------+-------------------+---------------------+
| 1         | 0.048452     | 0.945946          | 1.000000            |
| 2         | 0.111058     | 0.986486          | 0.928571            |
| 3         | 0.140735     | 0.986486          | 0.928571            |
| 4         | 0.174027     | 0.959459          | 0.928571            |
| 5         | 0.224935     | 0.952703          | 1.000000            |
| 10        | 0.384641     | 1.000000          | 1.000000            |
+-----------+--------------+-------------------+---------------------+
Completed (Iteration limit reached).

A la fin, CreateML va vous afficher un score de training qui correspondra à la précision de son analyse quant aux images fournies. Il vous est alors possible de glisser-déposer de nouvelles images et le réseau de neurones prédira s’il s’agit d’un pizza ou d’un hamburger.

On peut donc ensuite enregistrer son fichier .mlmodel qui est un modèle CoreML standard dont on pourra se servir dans nos projets.

 

On va s’arrêter ici pour le moment, nous y reviendrons bientôt pour voir comment intégrer ce modèle à un projet Xcode et s’en servir en Swift. J’espère que ce tutoriel vous a plu, nous en aurons d’autre sur l’IA et CreateML. A bientôt !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *