Il n'y a pas si longtemps, dans une galaxie assez éloignée, sur une planète provinciale, il y avait des descendants célèbres de singes si paresseux qu'ils ont décidé d'inventer l'intelligence artificielle. "Eh bien, quoi?" Ils ont pensé. C'est bien d'avoir dans les conseillers le ~~surmental un~~ "cerveau" qui pensera pour vous si nécessaire, vos problèmes peuvent être rapidement résolus, et c'est encore mieux qu'une créature vivante ne pourra jamais le faire ... Et, sans réfléchir aux conséquences, ils ont commencé leurs singes Le cerveau inversé et le processus cognitif sur les blocs de construction se démontent. Ils ont pensé, pensé et pensé, vous ne le croirez pas - un modèle de neurone, un algorithme d'apprentissage mathématique, puis des réseaux de neurones avec différentes topologies ont été créés. Bien sûr, cela n'a pas fonctionné pour dire très bien. Il y avait beaucoup de lacunes, par rapport à l'intelligence naturelle, mais un certain nombre de problèmes, ces modèles nous ont permis de résoudre avec une précision raisonnable. Et lentement, les compétences numérisées et sérialisées ont commencé à apparaître sous la forme de modèles de réseaux de neurones. Aujourd'hui, chers amoureux de l'histoire de l'univers, nous aborderons l'organisation et la mise en œuvre de diverses compétences en intelligence artificielle.

La création et la formation de modèles de réseaux de neurones (compétences) sur Habré est beaucoup écrit, donc nous n'en parlerons pas aujourd'hui. Après avoir formé ou reçu des compétences en IA sérialisées, nous nous attendons à les utiliser dans nos systèmes d'information cibles, et ici un problème se pose. Ce qui fonctionne sur le stand du laboratoire ne peut pas être transféré à la production sous sa forme d'origine, il est nécessaire de mettre en œuvre l'intégralité de la pile technologique associée et même d'apporter des modifications importantes à la plate-forme cible (il y a, bien sûr, des exceptions sous la forme de CoreML, mais c'est un cas spécial et uniquement pour les équipements Apple). De plus, il existe de très nombreux outils pour développer et sérialiser des modèles, est-il vraiment nécessaire que chacun développe une solution d'intégration distincte? De plus, même en laboratoire, il est souvent nécessaire d'obtenir une conclusion rapide du modèle, sans attendre le chargement de l'ensemble de la pile de développement associée.
À titre de suggestion pour résoudre ces problèmes, je voudrais vous parler d'un outil open source relativement nouveau, qui, peut-être, vous sera utile lors du développement de projets liés à l'IA.

0Mind (lire ZeroMind) est un serveur de compétences gratuit. La solution est un serveur d'applications modulaire, universel, facilement extensible avec des éléments de structure pour servir (sortie hautement accessible) des modèles d'apprentissage machine hétérogènes. Le serveur est laid en Python 3 et utilise Tornado pour le traitement des demandes asynchrones. Quel que soit le framework d'apprentissage automatique utilisé pour préparer et sérialiser le modèle, 0Mind facilite l'utilisation d'une compétence ou d'un groupe de compétences à l'aide de l'API REST universelle. En fait, la solution est un serveur Web asynchrone avec une API REST, unifiée pour travailler avec des modèles de compétence AI, et un ensemble d'adaptateurs pour divers cadres d'apprentissage automatique. Vous avez peut-être travaillé avec le service tensorflow - c'est une solution similaire, mais 0Mind n'est pas empilé tf et peut servir plusieurs modèles de frameworks différents sur le même port. Ainsi, au lieu d'implémenter l'intégralité de la pile technologique pour dériver des modèles d'IA dans le système d'information cible, vous pouvez utiliser l'API REST simple et familière à la compétence qui vous intéresse, en outre, le modèle préparé reste sur le serveur et ne se retrouve pas dans la distribution de logiciels. Afin de ne pas confondre à nouveau avec des termes complexes, nous allons passer à des exemples d'utilisation et commencer à lancer des sorts de console.

L'installation

Ici, tout est simple:

git clone git@github.com:MisteryX/0Mind.git 0Mind

Nous avons maintenant une instance de serveur qui fonctionne. Installez les dépendances:

 cd 0Mind pip3 install -r requirements.txt

Ou si vous utilisez Conda:

 conda install --yes --file requirements.txt

Une mise en garde importante est que le serveur prend en charge plusieurs frameworks d' apprentissage automatique et afin de ne pas les ajouter tous en fonction de celui-ci et de ne pas les installer, vous décidez vous-même des frameworks que vous allez charger sur l'hôte avec l'instance 0Mind, installez et configurez ces outils indépendamment.

Personnalisation

Le point d'entrée ou l'exécutable du serveur principal est model_pool.py .
Les options de démarrage possibles sont -c ou --config_file avec le chemin d'accès au fichier de configuration. Par défaut, 0Mind utilise le fichier configs / model_pool_config.json comme fichier de configuration. Le serveur utilise également le fichier config / logger.json pour contrôler la journalisation standard du module de journalisation Python.

Dans le but de démontrer les capacités, nous pouvons laisser le fichier de configuration par défaut intact. En savoir plus sur la configuration dans la documentation officielle .

Les principaux paramètres du serveur sont: id, hôte, port, tâches.

id - (numéro) identifiant unique du pool de modèles (utilisé pour l'équilibrage et l'adressage dans un réseau distribué de pools)
hôte - (chaîne) adresse réseau ou nom de domaine de cet hôte
port - (numéro) sur quel port souhaitez-vous héberger le service 0Mind (devrait être libre sur cet hôte)
tâches - (liste d'objets) une liste de tâches chargées avec le service (peut être vide). Dans la configuration par défaut, le modèle de démonstration CNN_MNIST préparé par Keras est chargé, et nous l'utiliserons pour démontrer les capacités.

Paramètres de configuration supplémentaires (facultatifs):

model_types - (liste de chaînes), vous pouvez limiter les types de modèles chargés à ce pool en les spécifiant dans cette liste. Si la liste est vide, il n'y a aucune restriction.

debug - (type booléen) est chargé d'activer ou de désactiver le mode de débogage de Tornado. En mode débogage, en cas d'erreurs, les informations d'erreur étendues sont renvoyées à stdout, ce qui est utile lors du développement d'extensions.

Les possibilités

L'essentiel dans 0Mind est la liste des frameworks pris en charge et les fonctionnalités de l'API REST .

Les demandes à l'API REST peuvent être effectuées à l'aide d'un navigateur ou d'utilitaires http. Dans ce guide, ainsi que dans la documentation du serveur, nous utiliserons cURL comme l'outil le plus simple et le plus abordable pour les systèmes ouverts.

Actuellement, l'API 0Mind a un total de 10 demandes:

1. http: // $ HOST: $ PORT / info - informations générales sur l'instance 0Mind
2. http: // $ HOST: $ PORT / info / system - informations système sur l'hôte sur lequel 0Mind s'exécute
3. http: // $ HOST: $ PORT / info / task - informations sur la tâche spécifiée
4. http: // $ HOST: $ PORT / info / tasks - liste des tâches de l'instance 0Mind
5. http: // $ HOST: $ PORT / model / list - une liste d'identifiants des modèles chargés dans le pool
6. http: // $ HOST: $ PORT / model / info - affiche les informations d'interface sur le modèle
7. http: // $ HOST: $ PORT / model / load - télécharge un nouveau modèle dans le pool
8. http: // $ HOST: $ PORT / model / drop - décharge un modèle précédemment chargé du pool
9. http: // $ HOST: $ PORT / modèle / prédire - demande la sortie du modèle
10.http: // $ HOST: $ PORT / command / stop - arrête le service 0Mind et termine son processus

L'information

Vous pouvez démarrer une instance de serveur, par exemple, comme ceci:

 python3 model_pool.py

Par exemple, nous obtiendrons des informations générales sur une instance de serveur en cours d'exécution:

 curl http://127.0.0.1:5885/info

 {"service": "ModelPool", "id": 1, "options": {"debug": false}, "version": [1, 1, 4]}

Ok, maintenant nous découvrons quels modèles sont chargés dans le pool:

 curl http://127.0.0.1:5885/model/list

 {"id": 1, "check_sum": "4d8a15e3cc35750f016ce15a43937620", "models": ["1"]}

Clarifions maintenant l'interface du modèle chargé avec l'identifiant «1»:

 curl http://127.0.0.1:5885/model/info?id=1

 {"inputs": {"0": {"name": "conv2d_1_input:0", "type": "float32", "shape": [null, 28, 28, 1]}}, "outputs": {"0": {"name": "dense_2/Softmax:0", "type": "float32", "shape": [null, 10]}}, "tool": "keras"}

Reste à savoir avec quels filtres le modèle est chargé. Pour ce faire, nous clarifions les détails de la tâche de chargement du modèle avec l'identifiant "1":

 curl http://127.0.0.1:5885/info/task?id=1

 {"id": "1", "model_file": "ML/models/mnist_cnn_model.keras", "model_type": "keras", "input_filters": {"conv2d_1_input:0": ["i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter"]}, "output_filters": {}}

Comme vous pouvez le voir, notre modèle a un filtre d'entrée - i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter et il filtre l'entrée avec le nom - conv2d_1_input: 0. Ce filtre convertit simplement le fichier image spécifié en un tenseur et le met à l'échelle en fonction de l'entrée du modèle. Les filtres sont un autre excellent outil généralisé de 0Mind. Étant donné que le prétraitement et le post-traitement des données pour les modèles sont identiques, vous pouvez simplement accumuler ces filtres pour une utilisation rapide dans d'autres travaux avec d'autres modèles, en indiquant la tâche souhaitée comme attribut pour charger le modèle.

Sortie de données du modèle (inférence)

Eh bien, maintenant que nous avons toutes les informations nécessaires pour l'inférence, nous pouvons tirer une conclusion du modèle. En entrée, nous utilisons l'image de la suite de tests incluse dans la distribution 0Mind samples / image5.png :

 curl -d '{"conv2d_1_input:0": [{"image_file": "samples/image5.png"}]}' -H "Content-Type:application/json" -X POST http://127.0.0.1:5885/model/predict?id=1

La seule entrée du modèle conv2d_1_input: 0 avec le filtre i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter est les données au format accepté par le filtre - [{"image_file": "samples / image5.png"}]. En réponse de 0Mind, nous obtenons la sortie du modèle:

 {"result": {"dense_2/Softmax:0": [[2.190017217283827e-21, 1.6761866200587505e-11, 2.2447325167271673e-14, 0.00011080023978138342, 1.881280855367115e-17, 0.9998891353607178, 1.6690393796396863e-16, 9.67975005705668e-12, 1.1265206161566871e-13, 2.086113400079359e-13]]}, "model_time": 0.002135753631591797}

Ainsi, la seule sortie du modèle «dense_2 / Softmax: 0» (voir les informations sur le modèle ci-dessus) nous a donné le vecteur de confiance du modèle dans la classification de cette image. Comme vous pouvez le voir, la probabilité la plus élevée est de 0,99 pour une classe avec un indice de 6 (les classes sont des nombres 0-9), ce qui correspond au nombre 5 . Ainsi, le modèle a réussi à faire face à la reconnaissance du manuscrit et a donné une conclusion avec une grande confiance. Le temps d'inférence du modèle sur l'hôte 0Mind était de 0,002135753631591797 secondes, car la sortie était sur un CPU x86 normal.

Chargement et déchargement dynamiques des modèles

Déchargez maintenant notre modèle de la piscine:

 curl http://127.0.0.1:5885/model/drop?id=1

 {"result": true, "unload_time": 0.000152587890625, "memory_released": 0, "model_id": "1"}

Nous chargeons à nouveau le même modèle, mais maintenant avec un identifiant différent («nouveau») et un filtre de sortie du modèle io_argmax.ArgMaxFilter, qui dérivera très probablement l'indice du vecteur de confiance du modèle. Nous devrons changer les indices des entrées et sorties du modèle - cela est dû aux caractéristiques de Keras:

 curl -d '{"id": "new", "output_filters": {"dense_2_1/Softmax:0": ["io_argmax.ArgMaxFilter"]}, "model_file": "ML/models/mnist_cnn_model.keras", "input_filters": {"conv2d_1_input_1:0": ["i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter"]}, "model_type": "keras"}' -H "Content-Type:application/json" -X POST http://127.0.0.1:5885/model/load

 {"result": true, "load_time": 0.45618462562561035, "memory_consumed": 16183296, "model_id": "new"}

Et maintenant, nous demandons au modèle de reconnaître pour nous deux images à la fois en une seule demande samples / image5.png et samples / image1.png :

 curl -d '{"conv2d_1_input:0": [{"image_file": "samples/image5.png"}, {"image_file": "samples/image1.png"}]}' -H "Content-Type:application/json" -X POST http://127.0.0.1:5885/model/predict?id=new

 {"result": {"dense_2_1/Softmax:0": [5, 1]}, "model_time": 0.003907206535339355}

Le modèle de démonstration ne s'est pas encore trompé.

Extension

Étendre les capacités de 0Mind n'est pas difficile, grâce à son architecture modulaire, l'utilisation d'outils populaires et de bonnes conventions de code dans le projet. Les principaux vecteurs d'extension peuvent être:

Les adaptateurs sont des classes intercouches pour travailler avec de nouveaux cadres d'apprentissage automatique et de réseaux de neurones.
Les filtres sont des gestionnaires de données permettant d'entrer et de quitter des modèles de compétences.
Gestionnaires de demandes - vous permettent d'ajouter de nouvelles fonctionnalités aux demandes et réponses de l'API 0Mind.

Servez tout