Bringen Sie mindestens Ihr eigenes Modell auf SageMaker mit

Nehmen wir an, Sie erhalten von einem Kollegen ein Notebook mit einem Modell und haben die Aufgabe, es in einer Produktionsumgebung zum Laufen zu bringen. Wenn Sie AWS nutzen, könnten Sie AWS SageMaker für diese Aufgabe einsetzen. Die SageMaker-Dokumentation mag zunächst etwas abschreckend wirken, mit einer Wand aus Text und wenig Beispielcode.

Dieser Blogbeitrag zeigt das Minimum an Code, das zum Trainieren und Bereitstellen eines (benutzerdefinierten) Modells auf AWS SageMaker erforderlich ist. SageMaker wird auch mit einer Reihe von vorgefertigten Docker-Images geliefert. Es könnte einfacher sein, diese zu verwenden, falls Ihr Framework unterstützt wird.

Komponenten für Ausbildung und Service

SageMaker bietet ein Framework, mit dem Sie Ihre Modelle sowohl trainieren als auch bereitstellen können (was sie "serve" nennen). Alles wird in Docker-Containern ausgeführt. Beginnen wir also mit einer minimalen Docker-Datei:

FROM continuumio/miniconda3:4.7.10

Die Images müssen zwei ausführbare Dateien enthalten:

1. eine ausführbare Datei namens train
2. eine ausführbare Datei namens serve

SageMaker führt docker run yourimage train bzw. docker run yourimage serve für das Training und die Ausgabe aus. Daher müssen beide ausführbaren Dateien im Image vorhanden sein. Abgesehen von der gesamten Infrastruktur funktioniert die Einrichtung von SageMaker in etwa wie folgt:

Wie Sie in der Abbildung sehen können, speichert AWS S3 die Trainingsartefakte und lädt diese bei der Bereitstellung des Modells in ein Volume /opt/ml. SageMaker hängt dieses Volume in den Container ein, um alle Artefakte aufzubewahren, und erwartet eine bestimmte Verzeichnisstruktur:

/opt/ml
├── Eingabe
│ ├── Konfiguration
│ │ ├── hyperparameters.json
│ │ └── resourceConfig.json
│ └── Daten
│ └──  
│ └── 
├── Modell
│ └──  

Dateien wie die hyperparameters.json sind konfigurierbar und werden automatisch in den Container eingebunden, aber das ist nicht Gegenstand dieses Blogbeitrags (lesen Sie hier mehr).

Lassen Sie uns zunächst einen (Dummy-)Trainingsauftrag erstellen (dies ist unsere ausführbare Datei train ):

#!/usr/bin/env python

def Zug():
    drucken("Trainieren Sie...")
    mit öffnen Sie("/opt/ml/model/model", "w") als fh:
        fh.Schreiben Sie("...Modellparameter hier...")

wenn __name__ == "__main__":
    Zug()

Der Trainingsauftrag trainiert (hypothetisch) das Modell und schreibt die Ausgabe nach /opt/ml/model/model. Der Name in /opt/ml/model/ spielt keine Rolle, aber wir nennen ihn vorerst model. Nach dem Training archiviert SageMaker den Inhalt von /opt/ml in einem Archiv mit dem Namen model.tar.gz auf S3, das beim Serving erneut geladen wird. Wichtig ist, dass dieses Script "so wie es ist" ausgeführt wird. Ohne #!/usr/bin/env python am Anfang wüsste das Betriebssystem nicht, dass es sich um ein Python-Skript handelt und was es damit anfangen soll.

Schauen wir uns als nächstes den Code für die Bereitstellung an. SageMaker bietet zwei Varianten für den Einsatz: (1) Hosting eines HTTPS-Endpunkts für einzelne Inferenzen und (2) Batch-Transformation für die Inferenz mehrerer Elemente. Die Stapeltransformation würde den Rahmen dieses Blogbeitrags sprengen, aber es sind nur kleine Änderungen erforderlich, um sie zum Laufen zu bringen.

Für HTTPS-Hosting benötigt SageMaker eine REST-API auf Port 8080 mit zwei Endpunkten:

1. /ping für Gesundheitschecks
2. /invocations für die Inferenz

#!/usr/bin/env python

von Flachmann importieren Flachmann, Antwort

app = Flachmann(__name__)

@app.route("/ping", Methoden=["GET"])
def ping():
    return Antwort(Antwort="n", Status=200)

@app.route("/invocations", Methoden=["POST"])
def vorhersagen():
    return Antwort(Antwort="Hier vorhersagen...", Status=200)

wenn __name__ == "__main__":
    app.laufen(Gastgeber="0.0.0.0", Hafen=8080)

Wichtig ist hier die Portnummer; SageMaker muss auf 8080 laufen.

Das Dockerfile mit diesen beiden Skripten und der Flask-API sieht wie folgt aus:

FROM continuumio/miniconda3:4.7.10

RUN pip install flask
COPY serve /usr/local/bin
COPY train /usr/local/bin
EXPOSE 8080

Die Skripte serve und train werden zu /usr/local/bin hinzugefügt, da sich dieses auf PATH im miniconda3 Image befindet. Sie können das Skript in jedem beliebigen Verzeichnis ablegen, solange es sich auf PATH befindet.

Alles zusammenbringen

SageMaker bietet ein (Python-)Framework, um diese Punkte zu verbinden. Zunächst müssen wir das Docker-Image zu ECR übertragen, um es für SageMaker verfügbar zu machen:

docker build -t helloworld .

Konto=$(aws sts get-caller-identity --query Konto --output text)
Region=$(aws configure get region)
$(aws ecr get-login --region  ${Region}  --no-include-email)
aws ecr create-repository --repository-name helloworld

Docker-Tag helloworld  "${Konto}.dkr.ecr.${Region}.amazonaws.com/helloworld:latest"
Docker-Push  ${Konto}.dkr.ecr.${Region}.amazonaws.com/helloworld:latest

Starten Sie dann ein SageMaker-Notizbuch und führen Sie den folgenden Code zum Trainieren des Modells aus:

importieren Sagemaker

Rolle = Sagemaker.get_execution_role()
Sitzung = Sagemaker.Sitzung()

Konto = Sitzung.boto_session.Kunde("sts").get_caller_identity()["Konto"]
Region = Sitzung.boto_session.region_name
Bild = f"{Konto}.dkr.ecr.{region}.amazonaws.com/helloworld:latest"

Modell = Sagemaker.Schätzer.Schätzer(
    image_name=Bild,
    Rolle=Rolle,
    train_instance_count=1,
    train_instance_type="ml.c4.2xlarge",
    sagemaker_session=Sitzung,
)

Modell.fit()

Das Wichtigste ist hier die Klasse Estimator, die eine Wrapper-Klasse für das Training jedes mitgelieferten Algorithmus ist. Geben Sie die richtigen Argumente wie image_name und train_instance_type an. SageMaker wird eine Maschine mit dem angegebenen Typ starten und Ihr Modell darauf trainieren. Beachten Sie, dass der obige Code nicht viel bewirkt - einen Rechner hochzufahren, nur um print("Do training...") auszuführen und eine Dummy-Datei zu speichern, ist offensichtlich unnötig, aber für die eigentliche Arbeit ist oft ein leistungsfähiger Rechner erforderlich.

Die Ausgabe dieses Codes sieht dann etwa so aus:

2019-10-04 14:30:58 Start - Beginn des Ausbildungsjobs...
2019-10-04 14:31:00 Starten - Starten der angeforderten ML-Instanzen......
2019-10-04 14:32:00 Starten - Vorbereiten der Instanzen für die Ausbildung...
2019-10-04 14:32:41 Herunterladen - Herunterladen von Eingabedaten
2019-10-04 14:32:41 Training - Herunterladen des Trainingsbildes...
2019-10-04 14:33:08 Hochladen - Hochladen des generierten Trainingsmodells
2019-10-04 14:33:08 Erledigt - Trainingsauftrag abgeschlossen
Training Sekunden: 35
Abrechenbare Sekunden: 35

Das Ergebnis ist ein Archiv model.tar.gz auf AWS S3, das die Artefakte des Modells enthält. Dabei kann es sich um ein gepickeltes Modell, eine einfache Textdatei mit den Modellparametern oder um etwas anderes handeln, das Sie beim Laden des Modells in der Serving-Phase für nützlich halten. Sehen wir uns nun den Code für das Serving an:

Prädiktor = Modell.einsetzen.(1, 'ml.t2.medium', endpunkt_name="helloworld")

Auch hier wird eine Maschine des angegebenen Typs in Gang gesetzt und das Modell auf einem bestimmten Endpunktnamen, in diesem Fall "helloworld", bereitgestellt. Wir können diesen Endpunkt von unserem Notebook aus aufrufen:

Prädiktor.vorhersagen(Daten="n")

b'Hier vorhersagen...'

Dieser Endpunkt ist nun von unserem Python-Notebook aus aufrufbar. Um ihn der Außenwelt zugänglich zu machen, könnten Sie ihn mit einem Lambda und einem API-Gateway aussetzen, wie in diesem Blogbeitrag erläutert.

Mitbringsel

Einige Erkenntnisse, die ich gewonnen habe, als ich ein benutzerdefiniertes Modell in SageMaker zum Laufen brachte:

• Die SageMaker-Entwicklerdokumentation ist recht umfangreich und es ist schwer, konkrete Beispiele zu finden. Eine nützliche Ressource war das SageMaker-Beispiel-Repository.
• train und serve Skripte müssen ausführbar sein und als Python-Code ausgeführt werden. Testen Sie lokal, nachdem Sie sie mit docker run yourimage train oder serve erstellt haben.
• Ihr Modell muss auf /opt/ml/model/... geschrieben werden.
• Ihre API muss auf Port 8080 verfügbar sein.

Ich hoffe, dies hilft Ihnen, Ihr benutzerdefiniertes Modell in SageMaker schnell zum Laufen zu bringen.