Bonjour à tous! Aujourd'hui, nous allons parler de la mise en œuvre de l'apprentissage automatique sur Scala. Je vais commencer par expliquer comment nous sommes arrivés à une telle vie. Ainsi, notre équipe a longtemps utilisé toutes les fonctionnalités du machine learning en Python. C'est pratique, il y a beaucoup de bibliothèques utiles pour la préparation des données, une bonne infrastructure pour le développement, je veux dire Jupyter Notebook. Tout irait bien, mais face au problème de la parallélisation des calculs en production, et a décidé d'utiliser Scala dans la prod. Pourquoi pas, nous pensions, il y a des tonnes de bibliothèques là -bas, même Apache Spark est écrit en Scala! Dans le même temps, nous développons aujourd'hui des modèles en Python, puis répétons la formation en Scala pour une sérialisation plus poussée et une utilisation en production. Mais, comme on dit, le diable est dans les détails.
Immédiatement, je tiens à préciser, cher lecteur, que cet article n'a pas été écrit pour saper la réputation de Python en matière d'apprentissage automatique. Non, l'objectif principal est d'ouvrir la porte au monde de l'apprentissage automatique sur Scala, de donner un bref aperçu de l'approche alternative qui découle de notre expérience et de vous dire quelles difficultés nous avons rencontrées.
Dans la pratique, il s'est avéré que ce n'était pas si joyeux: il n'y a pas beaucoup de bibliothèques qui implémentent des algorithmes d'apprentissage automatique classiques, mais celles qui sont souvent des projets OpenSource sans le soutien de grands fournisseurs. Oui, bien sûr, il y a Spark MLib, mais il est fortement lié à l'écosystème Apache Hadoop, et je ne voulais vraiment pas le faire glisser dans l'architecture de microservice.
Ce qu'il fallait, c'était une solution qui sauverait le monde et ramènerait un sommeil réparateur, et elle a été trouvée!
De quoi avez-vous besoin?
Lorsque nous avons choisi un outil d'apprentissage automatique, nous sommes partis des critères suivants:
- cela devrait ĂŞtre simple;
- malgré sa simplicité, personne n'a annulé une large fonctionnalité;
- Je voulais vraiment pouvoir développer des modèles dans l'interpréteur Web, et non via la console ou les assemblages et compilations constants;
- la disponibilité de la documentation joue un rôle important;
- idéalement, il y aurait un support au moins pour répondre aux problèmes de github.
Qu'avons-nous vu?
- Apache Spark MLib : ne nous convenait pas. Comme mentionné ci-dessus, cet ensemble de bibliothèques est fortement lié à la pile Apache Hadoop et à Spark Core lui-même, qui pèse trop pour construire des microservices basés sur lui.
- Apache PredictionIO : un projet intéressant, de nombreux contributeurs, il y a de la documentation avec des exemples. En fait, il s'agit d'un serveur REST sur lequel les modèles tournent. Il existe des modèles prêts à l'emploi, par exemple, la classification des textes, dont le lancement est décrit dans la documentation. La documentation décrit comment ajouter et former vos modèles. Nous ne nous sommes pas adaptés, car Spark est utilisé sous le capot, et cela relève davantage du domaine d'une solution monolithique, plutôt que d'une architecture de microservice.
- Apache MXNet : un cadre intéressant pour travailler avec des réseaux de neurones, il existe un support pour Scala et Python - c'est pratique, vous pouvez former un réseau de neurones en Python, puis charger le résultat enregistré de Scala lors de la création d'une solution de production. Nous l'utilisons dans des solutions de production, il y a un article séparé à ce sujet ici .
- Smile : très similaire au package scikit-learn pour Python. Il existe de nombreuses implémentations d'algorithmes classiques d'apprentissage automatique, une bonne documentation avec des exemples, un support sur github, un visualiseur intégré (propulsé par Swing), vous pouvez utiliser Jupyter Notebook pour développer des modèles. C'est exactement ce dont vous avez besoin!
Préparation de l'environnement
Nous avons donc choisi Smile. Je vais vous expliquer comment l'exécuter dans le bloc-notes Jupyter en utilisant l'algorithme de clustering k-means comme exemple. La première chose que nous devons faire est d'installer Jupyter Notebook avec le support Scala. Cela peut être fait via pip ou utiliser une image Docker déjà assemblée et configurée. Je suis pour une deuxième option plus simple.
Pour me faire des amis de Jupyter avec Scala, je voulais utiliser BeakerX, qui fait partie de l'image Docker, disponible dans le dépôt officiel de BeakerX. Cette image est recommandée dans la documentation Smile, et vous pouvez l'exécuter comme ceci:
Mais ici, le premier problème attendait: au moment de la rédaction de l'article, BeakerX 1.0.0 était installé dans l'image beakerx / beakerx, et la version 1.4.1 était déjà disponible dans le github officiel du projet (plus précisément, la dernière version 1.3.0, mais l'assistant contient 1.4.1, et ça marche :-)).
Il est clair que je veux travailler avec la dernière version, j'ai donc créé ma propre image basée sur BeakerX 1.4.1. Je ne vous ennuierai pas avec le contenu du Dockerfile, voici un
lien vers celui-ci.
Soit dit en passant, pour ceux qui utiliseront mon image, il y aura un petit bonus: dans le répertoire des exemples, il y a un exemple k-means pour une séquence aléatoire avec traçage (ce n'est pas une tâche complètement triviale pour les cahiers Scala).
Télécharger Smile in Jupyter Notebook
Excellent environnement préparé! Nous créons un nouveau cahier Scala dans un dossier de notre répertoire, puis nous devons télécharger les bibliothèques de Maven pour que Smile fonctionne.
%%classpath add mvn com.github.haifengl smile-scala_2.12 1.5.2
Après avoir exécuté le code, une liste des fichiers jar téléchargés apparaîtra dans son bloc de sortie.
Étape suivante: importation des packages nécessaires au fonctionnement de l'exemple.
import java.awt.image.BufferedImage import java.awt.Color import javax.imageio.ImageIO import java.io.File import smile.clustering._
Préparation des données pour le clustering
Nous allons maintenant résoudre le problème suivant: générer une image composée de zones de trois couleurs primaires - rouge, vert et bleu (R, G, B). L'une des couleurs de l'image prévaudra. Nous regroupons les pixels de l'image, prenons le cluster dans lequel il y aura le plus de pixels, changeons leur couleur en gris et construisons une nouvelle image à partir de tous les pixels. Résultat attendu: la zone de couleur prédominante deviendra grise, le reste de la zone ne changera pas de couleur.
À la suite de l'exécution de ce code, l'image suivante s'affiche:
Étape suivante: convertir l'image en un ensemble de pixels. Par pixel, nous entendons une entité avec les propriétés suivantes:
- coordonnée latérale large (x);
- coordonnée latérale étroite (y);
- valeur de couleur;
- valeur facultative du numéro de classe / cluster (avant la fin du clustering, il sera vide).
En tant qu'entité, il est pratique d'utiliser la
case class :
case class Pixel(x: Int, y: Int, rgbArray: Array[Double], clusterNumber: Option[Int] = None)
Ici, pour les valeurs de couleur, le tableau
rgbArray de trois valeurs de rouge, vert et bleu est utilisé (par exemple, pour le
Array(255.0, 0, 0) couleur rouge
Array(255.0, 0, 0) ).
Ceci termine la préparation des données.
Regroupement des couleurs des pixels
Nous avons donc une collection de pixels de trois couleurs primaires, nous allons donc regrouper les pixels en trois classes.
La documentation recommande de définir le paramètre
runs dans une plage de 10 Ă 20.
Lorsque ce code est exécuté, un objet de type
KMeans sera créé. Le bloc de sortie contiendra des informations sur les résultats du clustering:
K-Means distortion: 0.00000 Clusters of 230400 data points of dimension 3: 0 50813 (22.1%) 1 51667 (22.4%) 2 127920 (55.5%)
Un cluster contient plus de pixels que les autres. Maintenant, nous devons marquer notre collection de pixels avec des classes de 0 Ă 2.
Repeindre l'image
La seule chose qui reste est de sélectionner le cluster avec le plus grand nombre de pixels et de repeindre tous les pixels inclus dans ce cluster en gris (changer la valeur du tableau
rgbArray ).
Il n'y a rien de compliqué, juste grouper par numéro de cluster (c'est notre
Option:[Int] ), compter le nombre d'éléments dans chaque groupe et extraire le cluster avec le nombre maximum d'éléments. Ensuite, changez la couleur en gris uniquement pour les pixels qui appartiennent au cluster trouvé.
Créez une nouvelle image et enregistrez les résultats.
Rassembler une nouvelle image de la collection de pixels:
C'est ce que nous avons finalement fait.
Nous enregistrons les deux images.
ImageIO.write(testImage, "png", new File("testImage.png")) ImageIO.write(modifiedImage, "png", new File("modifiedImage.png"))
Conclusion
L'apprentissage automatique sur Scala existe. Pour implémenter les algorithmes de base, il n'est pas nécessaire de faire glisser une énorme bibliothèque. L'exemple ci-dessus montre que pendant le développement, vous ne pouvez pas abandonner les moyens habituels, le même bloc-notes Jupyter peut facilement devenir ami avec Scala.
Bien sûr, pour un aperçu complet de toutes les fonctionnalités de Smile, un article ne suffit pas, et cela n'était pas inclus dans les plans. La tâche principale - ouvrir la porte au monde de l'apprentissage automatique sur Scala - est, je pense, terminée. À vous de décider si vous souhaitez utiliser ces outils, et plus encore, les faire glisser en production ou non!
Les références