Industrielles maschinelles Lernen: 10 Designprinzipien
Heutzutage entstehen täglich neue Dienste, Anwendungen und andere wichtige Programme, die es ermöglichen, unglaubliche Dinge zu erschaffen: von der Software zur Steuerung einer SpaceX-Rakete bis zur Interaktion mit einem Wasserkocher im Nebenzimmer über ein Smartphone.
Und manchmal kommt jeder unerfahrene Programmierer, egal ob er ein leidenschaftlicher Startup oder ein gewöhnlicher Full Stack- oder Data Scientist ist, früher oder später zu der Erkenntnis, dass es bestimmte Regeln für das Programmieren und Erstellen von Software gibt, die das Leben erheblich vereinfachen.
In diesem Artikel werde ich kurz 10 Prinzipien beschreiben, wie man industrielles maschinelles Lernen so programmiert, dass es leicht in eine Anwendung/einen Dienst integriert werden kann, basierend auf der 12-Faktor-App-Methodik. . Meine Initiative besteht darin, das Bewusstsein für diese Technik zu schärfen, die vielen Entwicklern und Datenwissenschaftlern helfen kann.
Dieser Artikel ist ein Prolog zu einer Artikelserie über industrielles maschinelles Lernen. Darin werde ich weiter darüber sprechen, wie man tatsächlich ein Modell erstellt und in die Produktion bringt, wie man eine API dafür erstellt, sowie Beispiele aus verschiedenen Bereichen und Unternehmen, die ML in ihren Systemen integriert haben.
Prinzip 1: Eine Codebasis
Einige Programmierer vergessen Git in den ersten Phasen aus Faulheit, es herauszufinden (oder aus anderen Gründen). Entweder vergessen sie das Wort völlig, das heißt, sie werfen sich gegenseitig Dateien im Laufwerk zu/werfen einfach Text/senden in Taubenschlägen, oder sie denken nicht über ihren Arbeitsablauf nach und übergeben sie jeweils an ihren eigenen Zweig und dann an den Meister.
Dieses Prinzip besagt: haben eine Codebasis und viele Bereitstellungen.
Git kann sowohl in der Produktion als auch in der Forschung und Entwicklung (F&E) eingesetzt werden, wo es nicht so häufig zum Einsatz kommt.
Beispielsweise kann man in der R&D-Phase Commits mit unterschiedlichen Datenverarbeitungsmethoden und -modellen belassen, um dann das beste auszuwählen und problemlos weiter damit zu arbeiten.
Zweitens ist dies in der Produktion eine unersetzliche Sache – Sie müssen ständig beobachten, wie sich Ihr Code ändert und wissen, welches Modell die besten Ergebnisse lieferte, welcher Code am Ende funktionierte und was dazu führte, dass er nicht mehr funktionierte oder falsche Ergebnisse lieferte . Dafür sind Commits da!
Sie können auch ein Paket Ihres Projekts erstellen, es beispielsweise auf Gemfury platzieren und dann einfach Funktionen daraus für andere Projekte importieren, um sie nicht tausendmal neu zu schreiben, aber dazu später mehr.
Prinzip 2: Abhängigkeiten klar deklarieren und isolieren
Jedes Projekt verfügt über unterschiedliche Bibliotheken, die Sie von außen importieren, um sie irgendwo anzuwenden. Ob Python-Bibliotheken, Bibliotheken anderer Sprachen für verschiedene Zwecke oder Systemtools – Ihre Aufgabe ist:
- Deklarieren Sie Abhängigkeiten eindeutig, d. h. eine Datei, die alle Bibliotheken, Tools und deren Versionen enthält, die in Ihrem Projekt verwendet werden und installiert werden müssen (in Python kann dies beispielsweise mit Pipfile oder „requirements.txt“ erfolgen). A Link, der es gut verständlich macht: )
- Isolieren Sie während der Entwicklung Abhängigkeiten speziell für Ihr Programm. Sie möchten nicht ständig Versionen wechseln und beispielsweise Tensorflow neu installieren?
Auf diese Weise können sich Entwickler, die in Zukunft Ihrem Team beitreten, schnell mit den Bibliotheken und deren Versionen vertraut machen, die in Ihrem Projekt verwendet werden, und Sie haben auch die Möglichkeit, die für ein bestimmtes Projekt installierten Versionen und Bibliotheken selbst zu verwalten Projekt, das Ihnen hilft, Inkompatibilitäten von Bibliotheken oder deren Versionen zu vermeiden.
Ihre Anwendung sollte auch nicht auf Systemtools angewiesen sein, die möglicherweise auf einem bestimmten Betriebssystem installiert sind. Diese Tools müssen auch im Abhängigkeitsmanifest deklariert werden. Dies ist notwendig, um Situationen zu vermeiden, in denen die Version der Tools (sowie deren Verfügbarkeit) nicht mit den Systemtools eines bestimmten Betriebssystems übereinstimmt.
Auch wenn Curl auf fast allen Computern verwendet werden kann, sollten Sie es dennoch in Abhängigkeiten deklarieren, da es bei der Migration auf eine andere Plattform möglicherweise nicht vorhanden ist oder die Version nicht die ist, die Sie ursprünglich benötigt haben.
Ihre „requirements.txt“-Datei könnte beispielsweise so aussehen:
# Model Building Requirements
numpy>=1.18.1,<1.19.0
pandas>=0.25.3,<0.26.0
scikit-learn>=0.22.1,<0.23.0
joblib>=0.14.1,<0.15.0
# testing requirements
pytest>=5.3.2,<6.0.0
# packaging
setuptools>=41.4.0,<42.0.0
wheel>=0.33.6,<0.34.0
# fetching datasets
kaggle>=1.5.6,<1.6.0
Prinzip 3: Konfigurationen
Viele haben Geschichten von verschiedenen Entwicklern gehört, die versehentlich Code mit Passwörtern und anderen Schlüsseln von AWS in öffentliche Repositories auf GitHub hochgeladen haben und am nächsten Tag mit Schulden von 6000 oder sogar 50000 US-Dollar aufwachten.
Natürlich sind diese Fälle extrem, aber sehr bedeutsam. Wenn Sie Ihre Anmeldeinformationen oder andere für die Konfiguration benötigte Daten im Code speichern, machen Sie einen Fehler, und ich denke, es besteht keine Notwendigkeit, den Grund dafür zu erklären.
Eine Alternative dazu besteht darin, Konfigurationen in Umgebungsvariablen zu speichern. Sie können mehr über Umgebungsvariablen lesen .
Beispiele für Daten, die typischerweise in Umgebungsvariablen gespeichert werden:
- Domain Namen
- API-URLs/URIs
- Öffentliche und private Schlüssel
- Kontakte (Mail, Telefone usw.)
Auf diese Weise müssen Sie den Code nicht ständig ändern, wenn sich Ihre Konfigurationsvariablen ändern. Dadurch sparen Sie Zeit, Mühe und Geld.
Wenn Sie beispielsweise die Kaggle-API zum Durchführen von Tests verwenden (z. B. die Software herunterladen und das Modell damit ausführen, um beim Ausführen zu testen, ob das Modell gut funktioniert), sollten private Schlüssel von Kaggle, wie KAGGLE_USERNAME und KAGGLE_KEY, vorhanden sein in Umgebungsvariablen gespeichert.
Grundsatz 4: Dienste Dritter
Die Idee dabei ist, das Programm so zu erstellen, dass es hinsichtlich des Codes keinen Unterschied zwischen lokalen und Drittanbieter-Ressourcen gibt. Sie können beispielsweise sowohl lokales MySQL als auch Drittanbieter anbinden. Gleiches gilt für verschiedene APIs wie Google Maps oder Twitter API.
Um einen Drittanbieterdienst zu deaktivieren oder einen anderen zu verbinden, müssen Sie lediglich die Schlüssel in der Konfiguration in den Umgebungsvariablen ändern, worüber ich im obigen Absatz gesprochen habe.
Anstatt also beispielsweise den Pfad zu Dateien mit Datensätzen jedes Mal im Code anzugeben, ist es besser, die Pathlib-Bibliothek zu verwenden und den Pfad zu den Datensätzen in config.py zu deklarieren, sodass unabhängig davon, welchen Dienst Sie verwenden (für Beispiel CircleCI) konnte das Programm den Pfad zu den Datensätzen unter Berücksichtigung der Struktur des neuen Dateisystems im neuen Dienst herausfinden.
Prinzip 5. Build, Release, Laufzeit
Viele Leute in der Datenwissenschaft finden es nützlich, ihre Fähigkeiten im Software-Schreiben zu verbessern. Wenn wir möchten, dass unser Programm so selten wie möglich abstürzt und möglichst lange ohne Ausfälle funktioniert, müssen wir den Prozess der Veröffentlichung einer neuen Version in drei Phasen unterteilen:
- Bühne Baugruppen. Sie verwandeln Ihren Barecode mit einzelnen Ressourcen in ein sogenanntes Paket, das alle notwendigen Codes und Daten enthält. Dieses Paket wird als Assembly bezeichnet.
- Bühne freigeben – hier verbinden wir unsere Konfiguration mit der Assembly, ohne die wir unser Programm nicht veröffentlichen könnten. Dies ist nun eine vollständig startbereite Version.
- Als nächstes kommt die Bühne rennen. Hier geben wir die Anwendung frei, indem wir die erforderlichen Prozesse aus unserer Version ausführen.
Ein solches System zur Veröffentlichung neuer Versionen eines Modells oder der gesamten Pipeline ermöglicht die Rollentrennung zwischen Administratoren und Entwicklern, ermöglicht die Nachverfolgung von Versionen und verhindert unerwünschte Programmstopps.
Für die Release-Aufgabe wurden viele verschiedene Dienste erstellt, in denen Sie Prozesse schreiben können, die Sie selbst in einer .yml-Datei ausführen können (in CircleCI ist dies beispielsweise config.yml, um den Prozess selbst zu unterstützen). Wheely ist großartig darin, Pakete für Projekte zu erstellen.
Sie können Pakete mit verschiedenen Versionen Ihres Machine-Learning-Modells erstellen, diese dann verpacken und auf die erforderlichen Pakete und deren Versionen verweisen, um die von Ihnen geschriebenen Funktionen zu verwenden. Dadurch können Sie eine API für Ihr Modell erstellen und Ihr Paket kann beispielsweise auf Gemfury gehostet werden.
Prinzip 6. Führen Sie Ihr Modell als einen oder mehrere Prozesse aus
Darüber hinaus sollten Prozesse keine gemeinsamen Daten haben. Das heißt, Prozesse müssen separat vorhanden sein und alle Arten von Daten müssen separat vorhanden sein, beispielsweise auf Diensten von Drittanbietern wie MySQL oder anderen, je nachdem, was Sie benötigen.
Das heißt, es lohnt sich definitiv nicht, Daten im Prozessdateisystem zu speichern, da dies sonst dazu führen kann, dass diese Daten bei der nächsten Veröffentlichung/Konfigurationsänderung oder Übertragung des Systems, auf dem das Programm läuft, gelöscht werden.
Es gibt jedoch eine Ausnahme: Bei maschinellen Lernprojekten können Sie einen Cache mit Bibliotheken speichern, um diese nicht jedes Mal neu zu installieren, wenn Sie eine neue Version starten, wenn keine zusätzlichen Bibliotheken oder Änderungen an deren Versionen vorgenommen wurden. Auf diese Weise verkürzen Sie die Zeit, die bis zur Markteinführung Ihres Modells in der Industrie benötigt wird.
Um das Modell als mehrere Prozesse auszuführen, können Sie eine .yml-Datei erstellen, in der Sie die notwendigen Prozesse und deren Reihenfolge angeben.
Prinzip 7: Recyclingfähigkeit
Die Prozesse, die in Ihrer Modellanwendung ausgeführt werden, sollten einfach zu starten und zu stoppen sein. Auf diese Weise können Sie Codeänderungen und Konfigurationsänderungen schnell implementieren, schnell und flexibel skalieren und mögliche Ausfälle der Arbeitsversion verhindern.
Das heißt, Ihr Prozess mit dem Modell sollte:
- Minimieren Sie die Startzeit. Idealerweise sollte die Startzeit (vom Erteilen des Startbefehls bis zur Inbetriebnahme des Prozesses) nicht mehr als einige Sekunden betragen. Das oben beschriebene Bibliotheks-Caching ist eine Technik zur Reduzierung der Startzeit.
- Schluss richtig. Das heißt, die Überwachung des Service-Ports wird tatsächlich ausgesetzt und neue an diesen Port gesendete Anforderungen werden nicht verarbeitet. Hier müssen Sie entweder eine gute Kommunikation mit DevOps-Ingenieuren aufbauen oder selbst verstehen, wie es funktioniert (vorzugsweise natürlich Letzteres, aber die Kommunikation sollte in jedem Projekt immer aufrechterhalten werden!)
Prinzip 8: Kontinuierliche Bereitstellung/Integration
Viele Unternehmen nutzen eine Trennung zwischen den Anwendungsentwicklungs- und Bereitstellungsteams (um die Anwendung den Endbenutzern zur Verfügung zu stellen). Dies kann die Softwareentwicklung und Fortschritte bei der Verbesserung erheblich verlangsamen. Es verdirbt auch die DevOps-Kultur, in der Entwicklung und Integration grob gesagt kombiniert werden.
Daher besagt dieses Prinzip, dass Ihre Entwicklungsumgebung so nah wie möglich an Ihrer Produktionsumgebung sein sollte.
Dies ermöglicht:
- Reduzieren Sie die Release-Zeit um das Zehnfache
- Reduzieren Sie die Anzahl der Fehler aufgrund von Code-Inkompatibilität.
- Dies reduziert auch die Arbeitsbelastung der Mitarbeiter, da Entwickler und Anwendungsbereitsteller nun ein Team bilden.
Tools, mit denen Sie damit arbeiten können, sind CircleCI, Travis CI, GitLab CI und andere.
Sie können schnell Ergänzungen am Modell vornehmen, es aktualisieren und sofort starten, während es im Falle von Fehlern einfach ist, sehr schnell zur Arbeitsversion zurückzukehren, sodass der Endbenutzer es nicht einmal bemerkt. Dies geht besonders einfach und schnell, wenn gute Tests vorliegen.
Unterschiede minimieren!!!
Prinzip 9. Ihre Protokolle
Protokolle (oder „Protokolle“) sind Ereignisse, die normalerweise im Textformat aufgezeichnet werden und innerhalb der Anwendung auftreten (Ereignisstrom). Ein einfaches Beispiel: „2020 – Systemebene – Prozessname.“ Sie sind so konzipiert, dass der Entwickler buchstäblich sehen kann, was passiert, wenn das Programm ausgeführt wird. Er sieht den Fortschritt von Prozessen und versteht, ob sie so sind, wie es der Entwickler selbst beabsichtigt hat.
Dieses Prinzip besagt, dass Sie Ihre Protokolle nicht in Ihrem Dateisystem speichern sollten, sondern sie einfach auf dem Bildschirm „ausgeben“ sollten, beispielsweise über die Standardausgabe des Systems. Und auf diese Weise wird es möglich sein, den Fluss im Terminal während der Entwicklung zu überwachen.
Bedeutet das, dass überhaupt keine Protokolle gespeichert werden müssen? Natürlich nicht. Ihre Anwendung sollte dies einfach nicht tun – überlassen Sie es den Diensten von Drittanbietern. Ihre Anwendung kann Protokolle nur zur Echtzeitanzeige an eine bestimmte Datei oder ein bestimmtes Terminal weiterleiten oder sie an ein allgemeines Datenspeichersystem (z. B. Hadoop) weiterleiten. Ihre Anwendung selbst sollte keine Protokolle speichern oder mit ihnen interagieren.
Prinzip 10. Testen!
Für industrielles maschinelles Lernen ist diese Phase äußerst wichtig, da Sie verstehen müssen, dass das Modell korrekt funktioniert und das liefert, was Sie wollten.
Tests können mit pytest erstellt und mit einem kleinen Datensatz getestet werden, wenn Sie eine Regressions-/Klassifizierungsaufgabe haben.
Vergessen Sie nicht, den gleichen Ausgangspunkt für Deep-Learning-Modelle zu setzen, damit diese nicht ständig unterschiedliche Ergebnisse liefern.
Dies war eine kurze Beschreibung der 10 Prinzipien, und natürlich ist es schwierig, sie anzuwenden, ohne auszuprobieren und zu sehen, wie sie funktionieren. Daher ist dieser Artikel nur ein Prolog zu einer Reihe interessanter Artikel, in denen ich zeigen werde, wie man etwas kreiert Industrielle Modelle des maschinellen Lernens, wie man sie in Systeme integriert und wie diese Prinzipien das Leben für uns alle einfacher machen können.
Ich werde auch versuchen, coole Prinzipien zu verwenden, die jeder in den Kommentaren hinterlassen kann, wenn er möchte.
Source: habr.com