Vor nicht allzu langer Zeit gab es in einer ziemlich fernen Galaxie auf einem Provinzplaneten berühmte Nachkommen von Affen, die so faul waren, dass sie beschlossen, künstliche Intelligenz zu erfinden. "Nun, was?" Sie dachten. Es ist gut, in den Beratern des Overmind ein "Gehirn" zu haben, das bei Bedarf für Sie denkt, Ihre Probleme können schnell gelöst werden und es ist sogar noch besser, als es ein Lebewesen jemals tun kann ... Und ohne über die Konsequenzen nachzudenken, haben sie ihre Affen gestartet Umgekehrte Gehirne und der kognitive Prozess auf Bausteinen zerlegen sich. Sie dachten, dachten und dachten, Sie werden es nicht glauben - ein Neuronenmodell, ein mathematischer Lernalgorithmus und dann neuronale Netze mit unterschiedlichen Topologien. Das hat natürlich nicht sehr gut funktioniert. Im Vergleich zur natürlichen Intelligenz gab es viele Mängel, aber eine Reihe von Problemen, die wir mit diesen Modellen mit angemessener Genauigkeit lösen konnten. Und langsam tauchten digitalisierte und serialisierte Fähigkeiten in Form von neuronalen Netzwerkmodellen auf. Heute, liebe Liebhaber der Geschichte des Universums, werden wir die Organisation und Implementierung verschiedener Fähigkeiten der künstlichen Intelligenz ansprechen.


Über die Erstellung und das Training von Modellen neuronaler Netze (Fähigkeiten) auf Habré wird viel geschrieben, daher werden wir heute nicht darüber sprechen. Nachdem wir serialisierte KI-Fähigkeiten trainiert oder erhalten haben, erwarten wir, dass sie in unseren Zielinformationssystemen verwendet werden. Hier tritt ein Problem auf. Was am Laborstand funktioniert, kann nicht in seiner ursprünglichen Form in die Produktion übertragen werden. Es ist erforderlich, den gesamten zugehörigen Technologie-Stack zu implementieren und sogar wesentliche Änderungen an der Zielplattform vorzunehmen (es gibt natürlich Ausnahmen in Form von CoreML, dies ist jedoch ein Sonderfall und nur für Apple-Geräte). Darüber hinaus gibt es sehr viele Tools zum Entwickeln und Serialisieren von Modellen. Ist es wirklich notwendig, dass jeder eine separate Integrationslösung entwickelt? Darüber hinaus ist es auch im Labor häufig erforderlich, eine schnelle Schlussfolgerung aus dem Modell zu ziehen, ohne auf das Laden des gesamten zugehörigen Entwicklungsstapels warten zu müssen.
Als Vorschlag zur Lösung dieser Probleme möchte ich Ihnen ein relativ neues OpenSource-Tool vorstellen, das Ihnen möglicherweise bei der Entwicklung von Projekten im Zusammenhang mit KI hilfreich sein wird.

0Mind (lesen Sie ZeroMind) ist ein kostenloser Skill-Server. Die Lösung ist ein modularer, universeller, leicht erweiterbarer Anwendungsserver mit Framework-Elementen für die Bereitstellung heterogener Modelle für maschinelles Lernen (leicht zugängliche Ausgabe). Der Server ist in Python 3 hässlich und verwendet Tornado für die asynchrone Anforderungsverarbeitung. Unabhängig davon, welches Framework für maschinelles Lernen zur Vorbereitung und Serialisierung des Modells verwendet wurde, erleichtert 0Mind die Verwendung einer Fertigkeit oder einer Gruppe von Fertigkeiten mithilfe der universellen REST-API. Tatsächlich ist die Lösung ein asynchroner Webserver mit einer REST-API, die für die Arbeit mit KI-Fähigkeitsmodellen vereinheitlicht ist, und einer Reihe von Adaptern für verschiedene Frameworks für maschinelles Lernen. Möglicherweise haben Sie mit Tensorflow-Serving gearbeitet - dies ist eine ähnliche Lösung, aber 0Mind ist nicht gestapelt und kann mehrere Modelle verschiedener Frameworks auf demselben Port bedienen. Anstatt den gesamten Technologie-Stack zum Ableiten von AI-Modellen im Zielinformationssystem zu implementieren, können Sie die einfache und vertraute REST-API für die interessierenden Fähigkeiten verwenden. Außerdem bleibt das vorbereitete Modell auf dem Server und landet nicht in der Softwareverteilung. Um nicht noch einmal mit komplexen Begriffen zu verwechseln, werden wir zu Anwendungsbeispielen übergehen und beginnen, Konsolenzauber zu wirken.

Installation

Hier ist alles einfach:

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

Jetzt haben wir eine funktionierende Serverinstanz. Installieren Sie die Abhängigkeiten:

 cd 0Mind pip3 install -r requirements.txt 

Oder wenn Sie Conda verwenden:

 conda install --yes --file requirements.txt 

Eine wichtige Einschränkung ist, dass der Server mehrere Frameworks für maschinelles Lernen unterstützt. Um nicht alle Frameworks abhängig davon hinzuzufügen und nicht damit zu installieren, entscheiden Sie selbst, welche Framework-Frameworks Sie mit der 0Mind-Instanz auf den Host laden, installieren und konfigurieren Sie diese Tools unabhängig voneinander.

Anpassung

Der Einstiegspunkt oder die ausführbare Datei des Hauptservers ist model_pool.py .
Mögliche Startoptionen sind -c oder --config_file mit dem Pfad zur Konfigurationsdatei. Standardmäßig verwendet 0Mind die Datei configs / model_pool_config.json als Konfigurationsdatei. Der Server verwendet auch die Datei config / logger.json , um die Standardprotokollierung des Python-Protokollierungsmoduls zu steuern.

Um die Funktionen zu demonstrieren, können wir die Standardkonfigurationsdatei intakt lassen. Weitere Informationen zur Konfiguration finden Sie in der offiziellen Dokumentation .

Die wichtigsten Servereinstellungen sind: ID, Host, Port, Aufgaben.

id - (Nummer) eindeutige Kennung des Modellpools (zum Ausgleichen und Adressieren in einem verteilten Netzwerk von Pools)
Host - (Zeichenfolge) Netzwerkadresse oder Domänenname dieses Hosts
port - (Nummer) an welchem ​​Port möchten Sie den 0Mind-Dienst hosten (sollte auf diesem Host frei sein)
Aufgaben - (Liste der Objekte) Eine Liste der Aufgaben, die mit dem Dienst geladen wurden (möglicherweise leer). In der Standardkonfiguration wird das von Keras erstellte CNN_MNIST-Demomodell geladen, und wir werden es verwenden, um die Funktionen zu demonstrieren.

Zusätzliche (optionale) Konfigurationsparameter:

model_types - (Liste der Zeichenfolgen) Sie können die Typen geladener Modelle auf diesen Pool beschränken, indem Sie sie in dieser Liste angeben . Wenn die Liste leer ist, gibt es keine Einschränkungen.

debug - (Boolescher Typ) ist für das Aktivieren oder Deaktivieren des Debug-Modus von Tornado verantwortlich. Im Debug-Modus werden im Fehlerfall erweiterte Fehlerinformationen an stdout zurückgegeben, was bei der Entwicklung von Erweiterungen hilfreich ist.

Die Möglichkeiten

Die Hauptsache in 0Mind ist die Liste der unterstützten Frameworks und der REST-API-Funktionen .

Anforderungen an die REST-API können mit einem Browser oder http-Dienstprogrammen ausgeführt werden. In diesem Handbuch sowie in der Dokumentation zum Server verwenden wir cURL als einfachstes und kostengünstigstes Tool für offene Systeme.

Derzeit hat die 0Mind-API insgesamt 10 Anforderungen:

1. http: // $ HOST: $ PORT / info - Allgemeine Informationen zur 0Mind-Instanz
2. http: // $ HOST: $ PORT / info / system - Systeminformationen über den Host, auf dem 0Mind ausgeführt wird
3. http: // $ HOST: $ PORT / info / task - Informationen zur angegebenen Aufgabe
4. http: // $ HOST: $ PORT / info / task - Aufgabenliste der Instanz 0Mind
5. http: // $ HOST: $ PORT / model / list - Eine Liste der Kennungen der in den Pool geladenen Modelle
6. http: // $ HOST: $ PORT / model / info - Zeigt Schnittstelleninformationen zum Modell an
7. http: // $ HOST: $ PORT / model / load - Lädt ein neues Modell in den Pool hoch
8. http: // $ HOST: $ PORT / model / drop - entlädt ein zuvor geladenes Modell aus dem Pool
9. http: // $ HOST: $ PORT / model / Predict - fordert die Ausgabe des Modells an
10.http: // $ HOST: $ PORT / command / stop - Stoppt den 0Mind-Dienst und beendet seinen Prozess

Informationen

Sie können beispielsweise eine Serverinstanz wie folgt starten:

 python3 model_pool.py 

Beispielsweise erhalten wir allgemeine Informationen zu einer laufenden Serverinstanz:

 curl http://127.0.0.1:5885/info 

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

Ok, jetzt finden wir heraus, welche Modelle in den Pool geladen werden:

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

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

Lassen Sie uns nun die Schnittstelle des geladenen Modells mit der Kennung "1" verdeutlichen:

 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"} 

Es bleibt abzuwarten, mit welchen Filtern das Modell geladen wird. Dazu klären wir die Details der Aufgabe des Ladens des Modells mit der Kennung "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": {}} 

Wie Sie sehen können, verfügt unser Modell über einen Eingabefilter - i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter - und filtert die Eingabe mit dem Namen - conv2d_1_input: 0. Dieser Filter konvertiert einfach die angegebene Bilddatei in einen Tensor und skaliert sie entsprechend der Modelleingabe. Filter sind ein weiteres großartiges verallgemeinertes 0Mind-Tool. Da die Vor- und Nachbearbeitung von Daten für Modelle identisch ist, können Sie diese Filter einfach zur schnellen Verwendung bei der weiteren Arbeit mit anderen Modellen akkumulieren und die gewünschte Aufgabe als Attribut zum Laden des Modells angeben.

Datenausgabe aus dem Modell (Inferenz)

Nun, da wir alle Informationen haben, die für die Schlussfolgerung erforderlich sind, können wir aus dem Modell eine Schlussfolgerung ziehen. Als Eingabe verwenden wir das Bild aus der Testsuite, das in der Verteilung 0Mind samples / image5.png enthalten ist :

 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 

An die einzige Eingabe des Modells "conv2d_1_input: 0" mit dem Filter "i_img_file_to_ns_arr.ImageFileToNormAndScaledNPArrayFilter" senden wir die Daten in dem vom Filter akzeptierten Format - [{"image_file": "samples / image5.png"}]. Als Antwort von 0Mind erhalten wir die Modellausgabe:

 {"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} 

Die einzige Ausgabe des Modells „dens_2 / Softmax: 0“ (siehe Informationen zum obigen Modell) gab uns den Vertrauensvektor des Modells für die Klassifizierung dieses Bildes. Wie Sie sehen können, beträgt die höchste Wahrscheinlichkeit 0,99 für eine Klasse mit einem Index von 6 (Klassen sind die Zahlen 0 bis 9), was der Zahl 5 entspricht . Somit hat das Modell die Anerkennung des Manuskripts erfolgreich bewältigt und mit hoher Sicherheit eine Schlussfolgerung gezogen. Die Inferenzzeit des Modells auf dem 0Mind-Host betrug 0,002135753631591797 Sekunden, weil Die Ausgabe erfolgte auf einer normalen x86-CPU.

Dynamisches Be- und Entladen von Modellen

Laden Sie jetzt unser Modell aus dem Pool:

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

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

Wir laden dasselbe Modell erneut, jedoch jetzt mit einem anderen Bezeichner („neu“) und einem Ausgabefilter des Modells io_argmax.ArgMaxFilter, der den Index höchstwahrscheinlich aus dem Modellvertrauensvektor ableitet. Wir müssen die Indizes der Ein- und Ausgänge des Modells ändern - dies liegt an den Funktionen von 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"} 

Und jetzt bitten wir das Modell, zwei Bilder gleichzeitig in einer Anfrage zu erkennen. Samples / image5.png und 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} 

Das Demomodell wurde nicht noch einmal verwechselt.

Erweiterung

Die Erweiterung der Funktionen von 0Mind ist dank seiner modularen Architektur, der Verwendung beliebter Tools und guter Codekonventionen im Projekt nicht schwierig. Die Haupterweiterungsvektoren können sein:

1. Adapter sind Interlayer-Klassen für die Arbeit mit neuen Frameworks für maschinelles Lernen und neuronale Netze.
2. Filter sind Datenhandler zum Eingeben und Verlassen von Fertigkeitsmodellen.
3. Anforderungshandler - Ermöglichen das Hinzufügen neuer Funktionen zu den 0Mind-API-Anforderungen und -Antworten.