Hallo zusammen! Ich bin Lebenslaufentwickler bei CROC. Seit nunmehr 3 Jahren realisieren wir Projekte im Bereich CV. In dieser Zeit haben wir viele Dinge getan, zum Beispiel: Wir haben die Fahrer überwacht, damit sie während der Fahrt nicht trinken, nicht rauchen, nicht telefonieren, auf die Straße schauen und nicht auf Träume oder Wolken ; Wir haben Personen erfasst, die auf gesonderten Fahrspuren fahren und mehrere Parkplätze beanspruchen; stellte sicher, dass die Arbeiter Helme, Handschuhe usw. trugen; einen Mitarbeiter identifiziert, der die Einrichtung betreten möchte; Wir haben gezählt, was wir konnten.
Warum mache ich das alles?
Im Prozess der Umsetzung von Projekten stoßen wir auf Unebenheiten, auf viele Unebenheiten, einige der Probleme, mit denen Sie entweder vertraut sind oder mit denen Sie in Zukunft vertraut werden werden.
Lassen Sie uns die Situation simulieren
Stellen wir uns vor, wir hätten einen Job bei einem jungen Unternehmen „N“ bekommen, dessen Aktivitäten mit ML zu tun haben. Wir arbeiten an einem ML-Projekt (DL, CV), wechseln dann aus irgendeinem Grund zu einem anderen Job, machen im Allgemeinen eine Pause und kehren zu unserem eigenen Neuron oder dem eines anderen zurück.
- Der Moment der Wahrheit kommt: Sie müssen sich irgendwie daran erinnern, wo Sie aufgehört haben, welche Hyperparameter Sie ausprobiert haben und vor allem, zu welchen Ergebnissen sie geführt haben. Es gibt viele Möglichkeiten, wer Informationen zu allen Starts speichert: im Kopf, in den Konfigurationen, im Notizblock, in einer Arbeitsumgebung in der Cloud. Ich habe zufällig eine Option gesehen, als Hyperparameter als kommentierte Zeilen im Code gespeichert wurden, im Allgemeinen eine reine Fantasie. Stellen Sie sich nun vor, dass Sie nicht zu Ihrem Projekt, sondern zum Projekt einer Person zurückgekehrt sind, die das Unternehmen verlassen hat, und dass Sie einen Code und ein Modell namens model_1.pb geerbt haben. Um das Bild zu vervollständigen und den ganzen Schmerz zu verdeutlichen, stellen wir uns vor, dass Sie auch ein Anfängerspezialist sind.
- Fortfahren. Um den Code auszuführen, müssen wir und alle, die damit arbeiten, eine Umgebung erstellen. Es kommt oft vor, dass sie es aus irgendeinem Grund nicht als unser Erbe hinterlassen haben. Dies kann auch zu einer nicht trivialen Aufgabe werden. Sie möchten mit diesem Schritt keine Zeit verschwenden, oder?
- Wir trainieren ein Modell (zum Beispiel einen Autodetektor). Wir kommen an den Punkt, an dem es sehr gut wird – es ist Zeit, das Ergebnis zu speichern. Nennen wir es car_detection_v1.pb. Dann trainieren wir ein weiteres - car_detection_v2.pb. Einige Zeit später unterrichten unsere Kollegen oder wir selbst immer mehr und nutzen dabei unterschiedliche Architekturen. Dadurch entsteht eine Reihe von Artefakten, deren Informationen mühsam gesammelt werden müssen (wir werden dies jedoch später tun, da wir vorerst vorrangigere Angelegenheiten haben).
- OK, jetzt ist alles vorbei! Wir haben ein Modell! Können wir mit dem Training des nächsten Modells beginnen, eine Architektur entwickeln, um ein neues Problem zu lösen, oder können wir etwas Tee trinken gehen? Und wer wird eingesetzt?
Probleme identifizieren
Die Arbeit an einem Projekt oder Produkt ist die Arbeit vieler Menschen. Und mit der Zeit gehen Leute und kommen wieder, es gibt mehr Projekte und die Projekte selbst werden komplexer. Auf die eine oder andere Weise werden Situationen aus dem oben beschriebenen Zyklus (und nicht nur) in bestimmten Kombinationen von Iteration zu Iteration auftreten. All dies führt zu Zeitverschwendung, Verwirrung, Nerven, möglicherweise Unzufriedenheit der Kunden und letztendlich zu Geldverlusten. Auch wenn wir normalerweise alle dem gleichen Schema folgen, glaube ich, dass niemand diese Momente immer wieder erleben möchte.
Wir haben also einen Entwicklungszyklus durchlaufen und sehen, dass es Probleme gibt, die gelöst werden müssen. Dazu benötigen Sie:
- Arbeitsergebnisse bequem speichern;
- Vereinfachen Sie den Prozess der Einbindung neuer Mitarbeiter.
- den Prozess der Bereitstellung einer Entwicklungsumgebung vereinfachen;
- Konfigurieren Sie den Modellversionierungsprozess.
- eine bequeme Möglichkeit zur Modellvalidierung haben;
- Finden Sie ein Tool zur Modellzustandsverwaltung.
- Finden Sie einen Weg, Modelle an die Produktion zu liefern.
Anscheinend ist es notwendig, einen Workflow zu entwickeln, der es Ihnen ermöglicht, diesen Lebenszyklus einfach und bequem zu verwalten? Diese Praxis wird MLOps genannt
MLOps, oder DevOps für maschinelles Lernen, ermöglicht Data Science- und IT-Teams die Zusammenarbeit und erhöht das Tempo der Modellentwicklung und -bereitstellung durch Überwachung, Validierung und Governance für Modelle für maschinelles Lernen.
Sie können Was denken die Google-Leute darüber? Aus dem Artikel geht klar hervor, dass MLOps eine ziemlich umfangreiche Sache ist.
Im weiteren Verlauf meines Artikels werde ich nur einen Teil des Prozesses beschreiben. Für die Umsetzung werde ich das MLflow-Tool verwenden, weil... Dies ist ein Open-Source-Projekt, für die Verbindung ist eine kleine Menge Code erforderlich und es besteht eine Integration mit gängigen ML-Frameworks. Sie können im Internet nach anderen Tools wie Kubeflow, SageMaker, Trains usw. suchen und vielleicht eines finden, das Ihren Anforderungen besser entspricht.
„Aufbau“ von MLOps am Beispiel der Verwendung des MLFlow-Tools
MLFlow ist eine Open-Source-Plattform für das Lebenszyklusmanagement von ml-Modellen ().
MLflow umfasst vier Komponenten:
- MLflow Tracking – behandelt die Probleme der Aufzeichnung von Ergebnissen und Parametern, die zu diesem Ergebnis geführt haben;
- MLflow-Projekt – ermöglicht es Ihnen, Code zu verpacken und auf jeder Plattform zu reproduzieren;
- MLflow-Modelle – verantwortlich für die Bereitstellung von Modellen für die Produktion;
- MLflow Registry – ermöglicht Ihnen das Speichern von Modellen und die Verwaltung ihres Status in einem zentralen Repository.
MLflow arbeitet mit zwei Entitäten:
- Der Start ist ein vollständiger Zyklus von Schulungen, Parametern und Metriken, anhand derer wir uns registrieren möchten.
- Ein Experiment ist ein „Thema“, das zusammenläuft.
Alle Schritte des Beispiels sind auf dem Betriebssystem Ubuntu 18.04 implementiert.
1. Stellen Sie den Server bereit
Damit wir unser Projekt einfach verwalten und alle notwendigen Informationen erhalten können, werden wir einen Server bereitstellen. Der MLflow-Tracking-Server besteht aus zwei Hauptkomponenten:
- Backend-Store – verantwortlich für die Speicherung von Informationen über registrierte Modelle (unterstützt 4 DBMS: MySQL, MSSQL, SQLite und PostgreSQL);
- Artefaktspeicher – verantwortlich für die Speicherung von Artefakten (unterstützt 7 Speicheroptionen: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP-Server, SFTP-Server, NFS, HDFS).
Da der Artefaktspeicher Nehmen wir der Einfachheit halber einen SFTP-Server.
- erstellen Sie eine Gruppe
$ sudo groupadd sftpg - Fügen Sie einen Benutzer hinzu und legen Sie ein Passwort für ihn fest
$ sudo useradd -g sftpg mlflowsftp $ sudo passwd mlflowsftp - Anpassung einiger Zugriffseinstellungen
$ sudo mkdir -p /data/mlflowsftp/upload $ sudo chown -R root.sftpg /data/mlflowsftp $ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload - Fügen Sie ein paar Zeilen zu /etc/ssh/sshd_config hinzu
Match Group sftpg ChrootDirectory /data/%u ForceCommand internal-sftp - Starten Sie den Dienst neu
$ sudo systemctl restart sshd
Da der Backend-Store Nehmen wir Postgresql.
$ sudo apt update
$ sudo apt-get install -y postgresql postgresql-contrib postgresql-server-dev-all
$ sudo apt install gcc
$ pip install psycopg2
$ sudo -u postgres -i
# Create new user: mlflow_user
[postgres@user_name~]$ createuser --interactive -P
Enter name of role to add: mlflow_user
Enter password for new role: mlflow
Enter it again: mlflow
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) n
Shall the new role be allowed to create more new roles? (y/n) n
# Create database mlflow_bd owned by mlflow_user
$ createdb -O mlflow_user mlflow_dbUm den Server zu starten, müssen Sie die folgenden Python-Pakete installieren (ich empfehle die Erstellung einer separaten virtuellen Umgebung):
pip install mlflow
pip install pysftpLasst uns unseren Server starten
$ mlflow server
--backend-store-uri postgresql://mlflow_user:mlflow@localhost/mlflow_db
--default-artifact-root sftp://mlflowsftp:mlflow@sftp_host/upload
--host server_host
--port server_port2. Tracking hinzufügen
Damit die Ergebnisse unseres Trainings nicht verloren gehen, zukünftige Entwicklergenerationen verstehen, was passiert, und damit ältere Kameraden und Sie den Lernprozess in Ruhe analysieren können, müssen wir Tracking hinzufügen. Unter Tracking versteht man das Speichern von Parametern, Metriken, Artefakten und weiteren Informationen zum Trainingsbeginn, in unserem Fall auf dem Server.
Ich habe zum Beispiel ein kleines erstellt auf Keras für die Segmentierung von allem, was drin ist . Um Tracking hinzuzufügen, habe ich eine Datei mlflow_training.py erstellt.
Hier sind die Zeilen, in denen die interessantesten Dinge passieren:
def run(self, epochs, lr, experiment_name):
# getting the id of the experiment, creating an experiment in its absence
remote_experiment_id = self.remote_server.get_experiment_id(name=experiment_name)
# creating a "run" and getting its id
remote_run_id = self.remote_server.get_run_id(remote_experiment_id)
# indicate that we want to save the results on a remote server
mlflow.set_tracking_uri(self.tracking_uri)
mlflow.set_experiment(experiment_name)
with mlflow.start_run(run_id=remote_run_id, nested=False):
mlflow.keras.autolog()
self.train_pipeline.train(lr=lr, epochs=epochs)
try:
self.log_tags_and_params(remote_run_id)
except mlflow.exceptions.RestException as e:
print(e)Hier ist self.remote_server ein kleiner Wrapper über die mlflow.tracking-Methoden. MlflowClient (ich habe es der Einfachheit halber erstellt), mit dessen Hilfe ich ein Experiment erstelle und es auf dem Server ausführe. Als nächstes gebe ich an, wo die Startergebnisse zusammengeführt werden sollen (mlflow.set_tracking_uri(self.tracking_uri)). Ich aktiviere die automatische Protokollierung mlflow.keras.autolog(). Derzeit unterstützt MLflow Tracking die automatische Protokollierung für TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Wenn Sie Ihr Framework oder Ihre Bibliothek nicht gefunden haben, können Sie sich jederzeit explizit anmelden. Wir beginnen mit dem Training. Registrieren Sie Tags und Eingabeparameter auf dem Remote-Server.
Ein paar Zeilen und Sie haben wie alle anderen Zugriff auf Informationen zu allen Markteinführungen. Cool?
3. Wir erstellen das Projekt
Lassen Sie uns nun den Start des Projekts vereinfachen. Fügen Sie dazu die Datei MLproject und conda.yaml zum Projektstamm hinzu.
MLprojekt
name: flow_segmentation
conda_env: conda.yaml
entry_points:
main:
parameters:
categories: {help: 'list of categories from coco dataset'}
epochs: {type: int, help: 'number of epochs in training'}
lr: {type: float, default: 0.001, help: 'learning rate'}
batch_size: {type: int, default: 8}
model_name: {type: str, default: 'Unet', help: 'Unet, PSPNet, Linknet, FPN'}
backbone_name: {type: str, default: 'resnet18', help: 'exampe resnet18, resnet50, mobilenetv2 ...'}
tracking_uri: {type: str, help: 'the server address'}
experiment_name: {type: str, default: 'My_experiment', help: 'remote and local experiment name'}
command: "python mlflow_training.py
--epochs={epochs}
--categories={categories}
--lr={lr}
--tracking_uri={tracking_uri}
--model_name={model_name}
--backbone_name={backbone_name}
--batch_size={batch_size}
--experiment_name={experiment_name}"Das MLflow-Projekt verfügt über mehrere Eigenschaften:
- Name – der Name Ihres Projekts;
- Umgebung – in meinem Fall gibt conda_env an, dass Anaconda zum Ausführen verwendet wird und die Abhängigkeitsbeschreibung in der Datei conda.yaml enthalten ist;
- Einstiegspunkte – gibt an, welche Dateien und mit welchen Parametern wir ausführen können (alle Parameter werden automatisch protokolliert, wenn das Training beginnt)
conda.yaml
name: flow_segmentation
channels:
- defaults
- anaconda
dependencies:
- python==3.7
- pip:
- mlflow==1.8.0
- pysftp==0.2.9
- Cython==0.29.19
- numpy==1.18.4
- pycocotools==2.0.0
- requests==2.23.0
- matplotlib==3.2.1
- segmentation-models==1.0.1
- Keras==2.3.1
- imgaug==0.4.0
- tqdm==4.46.0
- tensorflow-gpu==1.14.0Sie können Docker als Laufzeitumgebung verwenden. Weitere Informationen finden Sie unter .
4. Beginnen wir mit dem Training
Wir klonen das Projekt und gehen in das Projektverzeichnis:
git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/Zum Ausführen müssen Sie Bibliotheken installieren
pip install mlflow
pip install pysftpWeil In dem Beispiel, das ich conda_env verwende, muss Anaconda auf Ihrem Computer installiert sein (Sie können dies jedoch umgehen, indem Sie alle erforderlichen Pakete selbst installieren und mit den Startparametern experimentieren).
Alle vorbereitenden Schritte sind abgeschlossen und wir können mit dem Start der Schulung beginnen. Aus dem Projektstamm:
$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .Nach Eingabe des Befehls wird automatisch eine Conda-Umgebung erstellt und das Training beginnt.
Im obigen Beispiel habe ich die Anzahl der Epochen für das Training übergeben, also die Kategorien, in die wir segmentieren möchten (Sie können die vollständige Liste sehen). ) und die Adresse unseres Remote-Servers.
Eine vollständige Liste der möglichen Parameter finden Sie in der MLproject-Datei.
5. Bewerten Sie die Lernergebnisse
Nach Abschluss des Trainings können wir im Browser auf die Adresse unseres Servers gehen
Hier sehen wir eine Liste aller Experimente (oben links) sowie Informationen zu Durchläufen (Mitte). Wir können für jeden Start detailliertere Informationen (Parameter, Metriken, Artefakte und einige zusätzliche Informationen) anzeigen.
Für jede Metrik können wir den Änderungsverlauf beobachten
Diese. Derzeit können wir die Ergebnisse im „manuellen“ Modus analysieren, und Sie können auch eine automatische Validierung mithilfe der MLflow-API einrichten.
6. Registrieren Sie das Modell
Nachdem wir unser Modell analysiert und entschieden haben, dass es kampfbereit ist, registrieren wir es. Dazu wählen wir den benötigten Start aus (wie im vorherigen Absatz gezeigt) und gehen nach unten.
Nachdem wir unserem Modell einen Namen gegeben haben, hat es eine Version. Wenn Sie ein anderes Modell mit demselben Namen speichern, wird die Version automatisch aktualisiert.
Für jedes Modell können wir eine Beschreibung hinzufügen und einen von drei Zuständen auswählen (Staging, Produktion, Archiviert); anschließend können wir über die API auf diese Zustände zugreifen, was zusammen mit der Versionierung zusätzliche Flexibilität bietet.
Außerdem haben wir einfachen Zugriff auf alle Modelle
und ihre Versionen
Wie im vorherigen Absatz können alle Vorgänge über die API durchgeführt werden.
7. Stellen Sie das Modell bereit
Zu diesem Zeitpunkt verfügen wir bereits über ein trainiertes (Keras-)Modell. Ein Beispiel, wie Sie es verwenden können:
class SegmentationModel:
def __init__(self, tracking_uri, model_name):
self.registry = RemoteRegistry(tracking_uri=tracking_uri)
self.model_name = model_name
self.model = self.build_model(model_name)
def get_latest_model(self, model_name):
registered_models = self.registry.get_registered_model(model_name)
last_model = self.registry.get_last_model(registered_models)
local_path = self.registry.download_artifact(last_model.run_id, 'model', './')
return local_path
def build_model(self, model_name):
local_path = self.get_latest_model(model_name)
return mlflow.keras.load_model(local_path)
def predict(self, image):
image = self.preprocess(image)
result = self.model.predict(image)
return self.postprocess(result)
def preprocess(self, image):
image = cv2.resize(image, (256, 256))
image = image / 255.
image = np.expand_dims(image, 0)
return image
def postprocess(self, result):
return resultHier ist self.registry der Einfachheit halber wieder ein kleiner Wrapper über mlflow.tracking.MlflowClient. Der Punkt ist, dass ich auf einen Remote-Server zugreife und dort nach einem Modell mit dem angegebenen Namen und der neuesten Produktionsversion suche. Als nächstes lade ich das Artefakt lokal in den Ordner ./model herunter und erstelle das Modell aus diesem Verzeichnis mlflow.keras.load_model(local_path). Jetzt können wir unser Modell verwenden. CV-Entwickler (ML) können das Modell problemlos verbessern und neue Versionen veröffentlichen.
Abschließend
Ich habe ein System vorgestellt, das Folgendes ermöglicht:
- Informationen über ML-Modelle, Trainingsfortschritte und Ergebnisse zentral speichern;
- schnell eine Entwicklungsumgebung bereitstellen;
- den Fortschritt der Arbeit an Modellen überwachen und analysieren;
- Es ist bequem, den Status von Modellen zu versionieren und zu verwalten.
- Die resultierenden Modelle lassen sich einfach bereitstellen.
Dieses Beispiel ist ein Spielzeug und dient als Ausgangspunkt für den Aufbau Ihres eigenen Systems, das die Automatisierung der Ergebnisauswertung und Registrierung von Modellen umfassen kann (Punkte 5 bzw. 6), oder Sie werden die Versionierung von Datensätzen hinzufügen, oder vielleicht etwas anderes? Der Punkt, den ich ansprechen wollte, ist, dass man MLOps als Ganzes braucht, MLflow ist nur ein Mittel zum Zweck.
Schreiben Sie, auf welche Probleme Sie gestoßen sind, die ich nicht angezeigt habe?
Was würden Sie dem System hinzufügen, damit es Ihren Anforderungen entspricht?
Mit welchen Tools und Ansätzen lösen Sie die Probleme ganz oder teilweise?
PS: Ich hinterlasse ein paar Links:
Github-Projekt -
MLflow -
Meine geschäftliche E-Mail für Fragen – [E-Mail geschützt]
Unser Unternehmen veranstaltet regelmäßig verschiedene Veranstaltungen für IT-Spezialisten, zum Beispiel: Am 8. Juli um 19:00 Uhr Moskauer Zeit findet ein Lebenslauf-Treffen im Online-Format statt, bei Interesse können Sie teilnehmen, sich anmelden .
Source: habr.com