Comment construire un modèle d’apprentissage approfondi pour prédire la rétention des employés à l’aide de Keras et de TensorFlow

Keras est une API de réseau de neurones écrite en Python. Il fonctionne au-dessus de TensorFlow, CNTK ou http://deeplearning.net/. logiciel / theano / [theano]. C’est une abstraction de haut niveau de ces cadres d’apprentissage en profondeur et rend donc l’expérimentation plus rapide et plus facile. Keras est modulaire, ce qui signifie que la mise en œuvre est transparente, les développeurs pouvant rapidement étendre des modèles en ajoutant des modules.

TensorFlow est une bibliothèque de logiciels open-source pour l’apprentissage automatique. Cela fonctionne efficacement avec le calcul impliquant des tableaux; c’est donc un excellent choix pour le modèle que vous allez construire dans ce tutoriel. De plus, TensorFlow permet l’exécution de code sur une CPU ou un GPU, ce qui est une fonctionnalité utile, en particulier lorsque vous travaillez avec un jeu de données volumineux.

Dans ce tutoriel, vous construirez un modèle d’apprentissage approfondi permettant de prédire la probabilité qu’un employé quitte une entreprise. Conserver les meilleurs employés est un facteur important pour la plupart des organisations. Pour construire votre modèle, vous utiliserez cette base de données disponible chez Kaggle, qui comporte des fonctions permettant de mesurer la satisfaction des employés dans une entreprise. Pour créer ce modèle, vous utiliserez la couche Keras sequential pour créer les différentes couches du modèle.

Avant de commencer ce tutoriel, vous aurez besoin des éléments suivants:

Le pré-traitement des données est nécessaire pour préparer vos données de manière à ce qu’un modèle d’apprentissage en profondeur puisse accepter. S’il y a des "variables catégoriques" dans vos données, vous devez les convertir en nombres car l’algorithme accepte uniquement les chiffres. Une variable catégorique représente des données quantitatives représentées par des noms. Dans cette étape, vous allez charger votre jeu de données en utilisant + pandas +, qui est une bibliothèque de manipulation de données Python.

Avant de commencer le prétraitement des données, vous devez activer votre environnement et vous assurer que tous les packages nécessaires sont installés sur votre ordinateur. Il est avantageux d’utiliser + conda + pour installer + keras + et + tensorflow + car il gèrera l’installation des dépendances nécessaires pour ces paquets, et s’assurera qu’ils sont compatibles avec + keras + et + tensorflow +. De cette manière, l’utilisation de la distribution Anaconda Python est un bon choix pour les projets liés à la science des données.

Accédez à l’environnement créé dans le didacticiel préalable:

Exécutez la commande suivante pour installer + keras + et + tensorflow +:

Maintenant, ouvrez Jupyter Notebook pour commencer. Jupyter Notebook est ouvert en tapant la commande suivante sur votre terminal:

Après avoir accédé à Jupyter Notebook, cliquez sur le fichier * anaconda3 *, puis sur * Nouveau * en haut de l’écran et sélectionnez * Python 3 * pour charger un nouveau carnet.

Vous allez maintenant importer les modules requis pour le projet, puis charger le jeu de données dans une cellule de classeur. Vous allez charger dans le module + pandas + pour manipuler vos données et + numpy + pour convertir les données en tableaux + numpy +. Vous allez également convertir toutes les colonnes au format chaîne en valeurs numériques à traiter par votre ordinateur.

Insérez le code suivant dans une cellule du classeur, puis cliquez sur * Exécuter *:

Vous avez importé + numpy et` + pandas`. Vous avez ensuite utilisé + pandas + pour charger l’ensemble de données du modèle.

Vous pouvez avoir un aperçu de l’ensemble de données avec lequel vous travaillez en utilisant + head () +. C’est une fonction utile de + pandas + qui vous permet de visualiser les cinq premiers enregistrements de votre cadre de données. Ajoutez le code suivant à une cellule du bloc-notes, puis exécutez-le:

image: https: //assets.digitalocean.com/articles/deeplearningkeras/step1a.png [Alt Vérification de l’en-tête du jeu de données]

Vous allez maintenant procéder à la conversion des colonnes catégoriques en nombres. Vous faites cela en les convertissant en dummy variables. Les variables nominales sont généralement des unités et des zéros indiquant la présence ou l’absence d’une caractéristique catégorique. Dans ce genre de situation, vous évitez également la variable dummy trap en supprimant le premier mannequin.

Insérez ce code dans la prochaine cellule du cahier et exécutez-le:

+ feats = ['département', 'salaire'] + définit les deux colonnes pour lesquelles vous souhaitez créer des variables nominales. + pd.get_dummies (df, columns = exploits, drop_first = True) + générera les variables numériques requises par votre modèle de fidélisation des employés. Pour ce faire, il convertit les + feats + que vous définissez de variables catégorielles en variables numériques.

image: https: //assets.digitalocean.com/articles/deeplearningkeras/step1b.png [Étape 1]

Vous avez chargé dans le jeu de données et converti les colonnes de salaire et de service dans un format que le modèle d’apprentissage approfondi + keras + peut accepter. Dans l’étape suivante, vous allez scinder le jeu de données en un ensemble de formation et de test.

Vous utiliserez https://scikit-learn.org/ [+ scikit-learn +] pour diviser votre jeu de données en un ensemble de formation et de test. Cela est nécessaire pour pouvoir utiliser une partie des données relatives aux employés pour former le modèle et une partie pour tester ses performances. La division d’un jeu de données de cette manière est une pratique courante lors de la création de modèles d’apprentissage en profondeur.

Il est important d’implémenter cette division dans le jeu de données afin que le modèle que vous construisez n’ait pas accès aux données de test pendant le processus de formation. Cela garantit que le modèle apprend uniquement à partir des données d’apprentissage et que vous pouvez ensuite tester ses performances avec les données de test. Si vous exposez votre modèle à des tests de données pendant le processus de formation, les résultats attendus seront mémorisés. Par conséquent, il ne donnerait pas de prévisions précises sur des données qu’il n’a pas vues.

Vous commencerez par importer le module + train_test_split + à partir du paquet + scikit-learn +. C’est le module qui fournira la fonctionnalité de fractionnement. Insérez ce code dans la prochaine cellule du cahier et exécutez:

Avec le module + train_test_split + importé, vous utiliserez la colonne + left + de votre jeu de données pour prédire si un employé quittera l’entreprise. Par conséquent, il est essentiel que votre modèle d’apprentissage en profondeur n’entre pas en contact avec cette colonne. Insérez ce qui suit dans une cellule pour supprimer la colonne + left +:

Votre modèle d’apprentissage en profondeur s’attend à obtenir les données sous forme de tableaux. Par conséquent, vous utilisez http://www.numpy.org/ [+ numpy +] pour convertir les données en tableaux + numpy + avec l’attribut + .values ​​+.

Vous êtes maintenant prêt à convertir l’ensemble de données en un ensemble d’essais et de formation. Vous utiliserez 70% des données pour la formation et 30% pour les tests. Le ratio de formation est supérieur au ratio de test car vous devrez utiliser la plupart des données pour le processus de formation. Si vous le souhaitez, vous pouvez également expérimenter avec un ratio de 80% pour l’ensemble d’apprentissage et de 20% pour l’ensemble d’essai.

Ajoutez maintenant ce code à la cellule suivante et exécutez-le pour fractionner vos données d’entraînement et de test selon le ratio spécifié:

image: https: //assets.digitalocean.com/articles/deeplearningkeras/step2.png [Étape 2]

Vous avez maintenant converti les données dans le type dans lequel Keras s’attend à ce qu’elles soient (tableaux + numpy +), et vos données sont divisées en un ensemble d’apprentissage et de test. Vous passerez ces données au modèle + keras + plus tard dans le tutoriel. Au préalable, vous devez transformer les données, que vous compléterez à l’étape suivante.

Lors de la création de modèles d’apprentissage en profondeur, il est généralement préférable de _ mettre à l’échelle_ votre jeu de données afin de rendre les calculs plus efficaces. Dans cette étape, vous allez mettre les données à l’échelle à l’aide de + StandardScaler +; Cela garantira que vos valeurs de jeu de données ont une moyenne de zéro et une variable d’unité. Cela transforme le jeu de données en distribution normale. Vous utiliserez le + scikit-learn + + + StandardScaler + pour adapter les fonctionnalités à la même plage. Cela transformera les valeurs pour avoir une moyenne de 0 et un écart type de 1. Cette étape est importante car vous comparez des entités ayant différentes mesures. il est donc généralement nécessaire dans l’apprentissage automatique.

Pour mettre à l’échelle l’ensemble d’apprentissage et l’ensemble de test, ajoutez ce code à la cellule du bloc-notes et exécutez-le:

Ici, vous commencez par importer le + StandardScaler + et en appelant une instance. Vous utilisez ensuite sa méthode + fit_transform + pour mettre à l’échelle l’ensemble de formation et de test.

Vous avez mis à l’échelle toutes les entités de votre jeu de données afin qu’elles se situent dans la même plage. Vous pouvez commencer à construire le réseau de neurones artificiels à l’étape suivante.

Vous allez maintenant utiliser + keras + pour construire le modèle d’apprentissage en profondeur. Pour ce faire, vous importerez + keras +, qui utilisera + tensorflow + comme moteur par défaut. A partir de + keras +, vous importerez ensuite le module + Sequential + pour initialiser le _ réseau de neurones artificiel_. Un réseau neuronal artificiel est un modèle informatique construit sur l’inspiration du fonctionnement du cerveau humain. Vous importerez également le module + Dense +, ce qui ajoutera des couches à votre modèle d’apprentissage approfondi.

Lors de la construction d’un modèle d’apprentissage en profondeur, vous spécifiez généralement trois types de couche:

Pour importer les modules + Keras +, + Sequential +, et + Dense +, exécutez le code suivant dans la cellule de votre carnet:

Vous utiliserez + Sequential + pour initialiser une pile linéaire de calques. Comme il s’agit d’un problème de classification, vous allez créer une variable de classificateur. Un problème de classification est une tâche dans laquelle vous avez étiqueté des données et souhaitez effectuer des prévisions basées sur les données étiquetées. Ajoutez ce code à votre bloc-notes pour créer une variable de classificateur:

Vous avez utilisé + Sequential + pour initialiser le classifieur.

Vous pouvez maintenant commencer à ajouter des couches à votre réseau. Exécutez ce code dans votre prochaine cellule:

Vous ajoutez des couches à l’aide de la fonction + .add () + sur votre classificateur et spécifiez certains paramètres:

Maintenant, vous allez ajouter la couche de sortie qui vous donnera les prédictions:

La couche de sortie prend les paramètres suivants:

Ensuite, vous appliquerez une gradient descente au réseau de neurones. C’est une stratégie d’optimisation qui réduit les erreurs pendant le processus de formation. La descente de gradient est la manière dont les poids attribués de manière aléatoire dans un réseau neuronal sont ajustés en réduisant la cost function, qui est une mesure de la performance d’un réseau neuronal sur la base des résultats attendus.

Le but d’une descente de gradient est d’obtenir le point où l’erreur est au minimum. Ceci est fait en recherchant où la fonction de coût est à son minimum, ce qui est appelé un minimum local. En descente, vous faites la différence pour trouver la pente en un point spécifique et déterminer si la pente est négative ou positive: vous descendez dans le minimum de la fonction de coût. Il existe plusieurs types de stratégies d’optimisation, mais vous en utiliserez une connue sous le nom + adam + dans ce didacticiel.

Ajoutez ce code à la cellule de votre carnet et exécutez-le:

L’application de la descente de gradient se fait via la fonction + compile + qui prend les paramètres suivants:

Vous êtes prêt à adapter votre classificateur à votre ensemble de données. Keras rend cela possible via la méthode + .fit () +. Pour ce faire, insérez le code suivant dans votre bloc-notes et exécutez-le afin d’adapter le modèle à votre jeu de données:

image: https: //assets.digitalocean.com/articles/deeplearningkeras/step4a.png [Ajustement du jeu de données]

La méthode + .fit () + prend quelques paramètres:

image: https: //assets.digitalocean.com/articles/deeplearningkeras/step4b.png [Étape 4]

Vous avez créé votre modèle d’apprentissage en profondeur, l’avez compilé et l’a adapté à votre jeu de données. Vous êtes prêt à faire des prévisions en utilisant le modèle d’apprentissage en profondeur. À l’étape suivante, vous commencerez à faire des prédictions avec le jeu de données que le modèle n’a pas encore vu.

Pour commencer à faire des prédictions, vous utiliserez le jeu de données de test dans le modèle que vous avez créé. Keras vous permet de faire des prédictions en utilisant la fonction + .predict () +.

Insérez le code suivant dans la cellule suivante du carnet pour commencer à faire des prédictions:

Etant donné que vous avez déjà formé le classificateur avec le jeu de formation, ce code utilisera les leçons tirées du processus de formation pour établir des prédictions sur le jeu de tests. Cela vous donnera les probabilités de départ d’un employé. Vous travaillerez avec une probabilité de 50% et plus pour indiquer une probabilité élevée que l’employé quitte l’entreprise.

Entrez la ligne de code suivante dans la cellule de votre carnet afin de définir ce seuil:

Vous avez créé des prévisions à l’aide de la méthode de prévision et défini le seuil permettant de déterminer si un employé est susceptible de partir. Pour évaluer la performance du modèle sur les prévisions, vous utiliserez ensuite une matrice de confusion.

Dans cette étape, vous utiliserez une matrice de confusion pour vérifier le nombre de prédictions correctes et incorrectes. Une matrice de confusion, également appelée matrice d’erreur, est une matrice carrée indiquant le nombre de vrais positifs (tp), de faux positifs (fp), de vrais négatifs (tn) et de faux négatifs (fn) d’un classificateur.

Pour ce faire, vous utiliserez une matrice de confusion fournie par + scikit-learn +.

Insérez ce code dans la cellule suivante du bloc-notes pour importer la matrice de confusion + scikit-learn +:

Le résultat de la matrice de confusion signifie que votre modèle d’apprentissage approfondi a fait les prédictions correctes «3305 + 375 +» et les prédictions erronées «+106 + 714 +». Vous pouvez calculer la précision avec: ` (3305 + 375) / 4500 +`. Le nombre total d’observations dans votre jeu de données est 4500. Cela vous donne une précision de 81,7%. C’est un très bon taux de précision car vous pouvez obtenir au moins 81% de prévisions correctes à partir de votre modèle.

Vous avez évalué votre modèle en utilisant la matrice de confusion. Ensuite, vous travaillerez sur une prédiction unique en utilisant le modèle que vous avez développé.

Dans cette étape, vous effectuerez une seule prévision en fonction des détails d’un employé associé à votre modèle. Vous y parviendrez en prédisant la probabilité qu’un seul employé quitte l’entreprise. Vous passerez les fonctionnalités de cet employé à la méthode ` prédire + ''. Comme vous l’avez fait précédemment, vous allez également redimensionner les fonctionnalités et les convertir en un tableau `+ numpy +.

Pour transmettre les fonctionnalités de l’employé, exécutez le code suivant dans une cellule:

Ces caractéristiques représentent les caractéristiques d’un seul employé. Comme indiqué dans le jeu de données à l’étape 1, ces caractéristiques représentent: le niveau de satisfaction, la dernière évaluation, le nombre de projets, etc. Comme vous l’avez fait à l’étape 3, vous devez transformer les fonctionnalités d’une manière que le modèle d’apprentissage en profondeur peut accepter.

Ajoutez un seuil de 50% avec le code suivant:

Ce seuil indique que, lorsque la probabilité est supérieure à 50%, un employé quittera l’entreprise.

Vous voyez dans votre sortie que l’employé ne quittera pas l’entreprise:

Vous pouvez décider de définir un seuil inférieur ou supérieur pour votre modèle. Par exemple, vous pouvez définir le seuil sur 60%:

Ce nouveau seuil indique toujours que l’employé ne quittera pas l’entreprise:

Dans cette étape, vous avez vu comment faire une seule prévision en fonction des caractéristiques d’un seul employé. Dans la prochaine étape, vous travaillerez à améliorer la précision de votre modèle.

Si vous entraînez votre modèle plusieurs fois, vous obtiendrez des résultats différents. Les précisions pour chaque entraînement ont une grande variance. Pour résoudre ce problème, vous utiliserez K-fold cross-validation. Habituellement, K est défini sur 10. Dans cette technique, le modèle est formé sur les 9 premiers plis et testé sur le dernier pli. Cette itération continue jusqu’à ce que tous les plis aient été utilisés. Chacune des itérations donne sa propre précision. La précision du modèle devient la moyenne de toutes ces précisions.

+ keras + vous permet d’implémenter la validation croisée des plis en utilisant le wrapper + KerasClassifier +. Ce wrapper provient de la validation croisée + scikit-learn +. Vous commencerez par importer la fonction de validation croisée + cross_val_score + et le + KerasClassifier +. Pour ce faire, insérez et exécutez le code suivant dans la cellule de votre carnet:

Pour créer la fonction que vous passerez au + KerasClassifier +, ajoutez ce code à la cellule suivante:

Ici, vous créez une fonction que vous passerez au + KerasClassifier + -la fonction est l’un des arguments attendus par le classificateur. La fonction est un wrapper de la conception de réseau de neurones que vous avez utilisée précédemment. Les paramètres transmis sont également similaires à ceux utilisés précédemment dans le didacticiel. Dans la fonction, vous initialisez le classifieur avec + Sequential () +, vous utilisez ensuite + Dense + pour ajouter les calques d’entrée et de sortie. Enfin, vous compilez le classifieur et le retournez.

Pour transmettre la fonction que vous avez créée au + KerasClassifier +, ajoutez cette ligne de code à votre bloc-notes:

Le + KerasClassifier + prend trois arguments:

Ensuite, vous appliquez la validation croisée à l’aide de Scikit-learn + cross_val_score. Ajoutez le code suivant à la cellule de votre carnet et exécutez-le:

Cette fonction vous donnera dix précisions puisque vous avez spécifié le nombre de plis à 10. Par conséquent, vous l’affectez à la variable de précision et l’utilisez ensuite pour calculer la précision moyenne. Il prend les arguments suivants:

Maintenant que vous avez appliqué la validation croisée, vous pouvez calculer la moyenne et la variance des précisions. Pour ce faire, insérez le code suivant dans votre cahier:

Dans votre document, vous verrez que la moyenne est de 83%:

Pour calculer la variance des précisions, ajoutez ce code à la prochaine cellule du cahier:

Vous voyez que la variance est 0.00109. Comme la variance est très faible, cela signifie que votre modèle fonctionne très bien.

Vous avez amélioré la précision de votre modèle en utilisant la validation croisée K-Fold. Dans la prochaine étape, vous travaillerez sur le problème de surajustement.

Les modèles prédictifs sont sujets à un problème appelé overfitting. Il s’agit d’un scénario dans lequel le modèle mémorise les résultats de l’entraînement et ne peut pas généraliser des données qu’il n’a pas vues. En général, vous observez un sur-ajustement lorsque la variance de précision est très élevée. Pour vous aider à lutter contre les surajustements dans votre modèle, vous allez ajouter une couche à votre modèle.

Dans les réseaux de neurones, la régularisation de gouttes est la technique qui permet de lutter contre la suralimentation en ajoutant une couche + Dropout + dans votre réseau de neurones. Il a un paramètre + rate + qui indique le nombre de neurones qui vont se désactiver à chaque itération. Le processus de désactivation des nerurons est généralement aléatoire. Dans ce cas, vous indiquez 0,1 comme taux, ce qui signifie que 1% des neurones seront désactivés pendant le processus d’entraînement. La conception du réseau reste la même.

Pour ajouter votre couche + Dropout +, ajoutez le code suivant à la cellule suivante:

Vous avez ajouté un calque + Dropout + entre les calques d’entrée et de sortie. Définir un taux d’abandon de 0,1 signifie que pendant le processus d’entraînement, 15 neurones seront désactivés, de sorte que le classificateur ne sur-adaptera pas le jeu d’apprentissage. Après avoir ajouté les couches + Dropout + et de sortie, vous avez ensuite compilé le classificateur comme vous l’avez fait précédemment.

Vous avez travaillé pour lutter contre le sur-ajustement dans cette étape avec un calque + Dropout +. Vous travaillerez ensuite à l’amélioration du modèle en ajustant les paramètres que vous avez utilisés lors de la création du modèle.

La recherche de grille est une technique que vous pouvez utiliser pour expérimenter différents paramètres de modèle afin d’obtenir ceux qui vous offrent la meilleure précision. La technique le fait en essayant différents paramètres et en renvoyant ceux qui donnent les meilleurs résultats. Vous utiliserez la recherche par grille pour rechercher les meilleurs paramètres pour votre modèle d’apprentissage en profondeur. Cela aidera à améliorer la précision du modèle. + scikit-learn + fournit la fonction + GridSearchCV + pour activer cette fonctionnalité. Vous allez maintenant modifier la fonction + make_classifier + pour essayer différents paramètres.

Ajoutez ce code à votre bloc-notes pour modifier la fonction + make_classifier + afin de pouvoir tester différentes fonctions de l’optimiseur:

Vous avez commencé par importer + GridSearchCV +. Vous avez ensuite apporté des modifications à la fonction + make_classifier + afin de pouvoir essayer différents optimiseurs. Vous avez initialisé le classificateur, ajouté les couches d’entrée et de sortie, puis compilé le classificateur. Enfin, vous avez renvoyé le classificateur afin que vous puissiez l’utiliser.

Comme à l’étape 4, insérez cette ligne de code pour définir le classificateur:

Vous avez défini le classificateur à l’aide de + KerasClassifier +, qui attend une fonction via le paramètre + build_fn +. Vous avez appelé le + KerasClassifier + et passé la fonction + make_classifier + que vous avez créée précédemment.

Vous allez maintenant définir quelques paramètres que vous souhaitez expérimenter. Entrez ce code dans une cellule et exécutez:

Ici, vous avez ajouté différentes tailles de lot, nombre d’époques et différents types de fonctions d’optimisation.

Pour un petit ensemble de données comme le vôtre, une taille de lot comprise entre 20 et 35, c’est bien. Pour les grands ensembles de données, il est important d’expérimenter de plus grandes tailles de lots. L’utilisation de nombres peu élevés pour le nombre d’époques garantit l’obtention de résultats dans un court laps de temps. Toutefois, vous pouvez expérimenter avec des nombres plus importants qui prendront un certain temps en fonction de la vitesse de traitement de votre serveur. Les optimiseurs + adam + et + rmsprop + de + keras + sont un bon choix pour ce type de réseau de neurones.

Vous allez maintenant utiliser les différents paramètres que vous avez définis pour rechercher les meilleurs paramètres à l’aide de la fonction + GridSearchCV +. Entrez ceci dans la cellule suivante et lancez-le:

La fonction de recherche dans la grille attend les paramètres suivants:

Ensuite, vous adaptez ce + grid_search + à votre ensemble de données d’entraînement:

Votre sortie ressemblera à la suivante, attendez un instant qu’elle soit terminée:

Ajoutez le code suivant à une cellule du bloc-notes pour obtenir les meilleurs paramètres de cette recherche à l’aide de l’attribut + best_params_ +:

Vous pouvez maintenant vérifier les meilleurs paramètres pour votre modèle avec le code suivant:

Votre sortie montre que la meilleure taille de lot est «+ 20 », le meilleur nombre d'époques est « 2 » et l'optimiseur « adam +» est le meilleur pour votre modèle:

Vous pouvez vérifier la meilleure précision pour votre modèle. Le «numéro de meilleure précision» représente la précision la plus élevée obtenue à partir des meilleurs paramètres après l’exécution de la recherche sur la grille:

Votre sortie sera semblable à la suivante:

Vous avez utilisé + GridSearch + pour déterminer les meilleurs paramètres pour votre classificateur. Vous avez vu que le meilleur + batch_size est 20, le meilleur` + optimizer` est l’optimiseur + adam + et le meilleur nombre d’épochs est 2. Vous avez également obtenu la meilleure précision pour votre classificateur à 85%. Vous avez créé un modèle de fidélisation des employés qui permet de prédire si un employé reste ou quitte avec une précision pouvant atteindre 85%.

Dans ce didacticiel, vous avez utilisé https://keras.io [Keras] pour créer un réseau de neurones artificiels permettant de prédire la probabilité qu’un employé quitte une entreprise. Vous avez combiné vos connaissances précédentes en apprentissage automatique en utilisant + scikit-learn + pour y parvenir. Pour améliorer encore votre modèle, vous pouvez essayer différentes fonctions activation ou optimizer de + keras +. Vous pouvez également expérimenter avec un nombre différent de plis, ou même créer un modèle avec un jeu de données différent.

Pour d’autres tutoriels dans le domaine du machine learning ou en utilisant TensorFlow, vous pouvez essayer de construire un https://www.digitalocean.com/community/tutorials/how-to-build-a-neural-network-to-recognize-handwritten-digits -with-tensorflow [réseau de neurones pour reconnaître les chiffres manuscrits] ou autres tutoriels d’apprentissage DigitalOcean machine.