

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erstellen von Modellpaket-Images
<a name="ml-model-package-images"></a>

Ein Amazon SageMaker AI-Modellpaket ist ein vortrainiertes Modell, das Vorhersagen trifft und keine weitere Schulung durch den Käufer erfordert. Sie können ein Modellpaket in SageMaker KI erstellen und Ihr Produkt für maschinelles Lernen darauf AWS Marketplace veröffentlichen. In den folgenden Abschnitten erfahren Sie, wie Sie ein Modellpaket für erstellen AWS Marketplace. Dazu gehören das Erstellen des Container-Images sowie das lokale Erstellen und Testen des Images.

**Topics**
+ [-Übersicht](#ml-model-package-images-overview)
+ [Erstellen Sie ein Inferenzbild für Modellpakete](#ml-creating-an-inference-image-for-model-packages)

## -Übersicht
<a name="ml-model-package-images-overview"></a>

 Ein Modellpaket umfasst die folgenden Komponenten: 
+  Ein in [Amazon Elastic Container Registry (Amazon](https://aws.amazon.com/ecr/) ECR) gespeichertes Inferenzbild 
+  (Optional) Modellartefakte, separat in [Amazon S3](https://aws.amazon.com/s3/) gespeichert 

**Anmerkung**  
Modellartefakte sind Dateien, die Ihr Modell verwendet, um Vorhersagen zu treffen. Sie sind in der Regel das Ergebnis Ihrer eigenen Trainingsprozesse. Bei Artefakten kann es sich um jeden Dateityp handeln, der für Ihr Modell benötigt wird, wobei jedoch die Komprimierung von use.tar.gz erforderlich ist. Modellpakete können entweder in Ihrem Inferenzbild gebündelt oder separat in Amazon SageMaker AI gespeichert werden. Die in Amazon S3 gespeicherten Modellartefakte werden zur Laufzeit in den Inferenzcontainer geladen. Bei der Veröffentlichung Ihres Modellpakets werden diese Artefakte veröffentlicht und in AWS Marketplace eigenen Amazon S3 S3-Buckets gespeichert, auf die der Käufer nicht direkt zugreifen kann. 

**Tipp**  
Wenn Ihr Inferenzmodell mit einem Deep-Learning-Framework wie Gluon, Keras,,,, TensorFlow -Lite oder ONNX erstellt wurde MXNet PyTorch TensorFlow, sollten Sie Amazon AI Neo in Betracht ziehen. SageMaker Neo kann automatisch Inferenzmodelle optimieren, die für eine bestimmte Familie von Cloud-Instanztypen wie, und andere eingesetzt werden. `ml.c4` `ml.p2` Weitere Informationen finden Sie unter [Optimieren der Modellleistung mithilfe von Neo](https://docs.aws.amazon.com/sagemaker/latest/dg/neo.html) im *Amazon SageMaker AI Developer Guide*.

Das folgende Diagramm zeigt den Arbeitsablauf für die Veröffentlichung und Verwendung von Modellpaketprodukten. 

![Diagramm, das zeigt, wie ein Verkäufer ein Bild eines Modellpakets erstellt und wie ein Käufer es verwendet.](http://docs.aws.amazon.com/de_de/marketplace/latest/userguide/images/ml-model-package-images.png)


Der Arbeitsablauf zur Erstellung eines SageMaker KI-Modellpakets für AWS Marketplace umfasst die folgenden Schritte:

1. Der Verkäufer erstellt ein Inferenz-Image (kein Netzwerkzugriff bei der Bereitstellung) und überträgt es in das Amazon ECR-Register. 

   Die Modellartefakte können entweder im Inferenz-Image gebündelt oder separat in S3 gespeichert werden.

1. Der Verkäufer erstellt dann eine Modellpaketressource in Amazon SageMaker AI und veröffentlicht sein ML-Produkt auf AWS Marketplace.

1. Der Käufer abonniert das ML-Produkt und stellt das Modell bereit. 
**Anmerkung**  
 Das Modell kann als Endpunkt für Echtzeit-Inferenzen oder als Batch-Job eingesetzt werden, um Vorhersagen für einen gesamten Datensatz auf einmal zu erhalten. Weitere Informationen finden Sie unter [Bereitstellen von Modellen für Inferenz](https://docs.aws.amazon.com/sagemaker/latest/dg/deploy-model.html). 

1. SageMaker KI führt das Inferenzbild aus. Alle vom Verkäufer bereitgestellten Modellartefakte, die nicht im Inferenzbild gebündelt sind, werden zur Laufzeit dynamisch geladen. 

1.  SageMaker KI leitet die Inferenzdaten des Käufers mithilfe der HTTP-Endpunkte des Containers an den Container weiter und gibt die Prognoseergebnisse zurück. 

## Erstellen Sie ein Inferenzbild für Modellpakete
<a name="ml-creating-an-inference-image-for-model-packages"></a>

Dieser Abschnitt enthält eine exemplarische Vorgehensweise zum Verpacken Ihres Inferenzcodes in ein Inferenzbild für Ihr Modellpaketprodukt. Der Prozess besteht aus den folgenden Schritten:

**Topics**
+ [Schritt 1: Erstellen Sie das Container-Image](#ml-step-1-creating-the-container-image)
+ [Schritt 2: Erstellen und testen Sie das Image lokal](#ml-step-2-building-and-testing-the-image-locally)

Das Inferenz-Image ist ein Docker-Image, das Ihre Inferenzlogik enthält. Der Container stellt zur Laufzeit HTTP-Endpunkte zur Verfügung, damit SageMaker KI Daten zu und von Ihrem Container weiterleiten kann. 

**Anmerkung**  
 Das Folgende ist nur ein Beispiel für einen Verpackungscode für ein Inferenzbild. Weitere Informationen finden Sie unter [Docker-Container mit SageMaker KI verwenden und die [AWS Marketplace SageMaker KI-Beispiele](https://github.com/aws/amazon-sagemaker-examples/tree/master/aws_marketplace)](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html) unter. GitHub  
Das folgende Beispiel verwendet der Einfachheit halber einen Webdienst, [Flask](https://pypi.org/project/Flask/), und gilt nicht als produktionsbereit.

### Schritt 1: Erstellen Sie das Container-Image
<a name="ml-step-1-creating-the-container-image"></a>

 Damit das Inferenz-Image mit SageMaker KI kompatibel ist, muss das Docker-Image HTTP-Endpunkte verfügbar machen. Während Ihr Container läuft, leitet SageMaker KI Käufereingaben zur Inferenz an den HTTP-Endpunkt des Containers weiter. Die Inferenzergebnisse werden im Hauptteil der HTTP-Antwort zurückgegeben. 

 In der folgenden exemplarischen Vorgehensweise wird die Docker-CLI in einer Entwicklungsumgebung verwendet, die eine Linux-Ubuntu-Distribution verwendet. 
+ [Erstellen Sie das Webserver-Skript](#ml-create-the-web-server-script)
+ [Erstellen Sie das Skript für den Containerlauf](#ml-create-the-script-for-the-container-run)
+ [Erstellen der `Dockerfile`](#ml-create-the-dockerfile)
+ [Package oder laden Sie die Modellartefakte hoch](#ml-package-or-upload-the-model-artifacts)

#### Erstellen Sie das Webserver-Skript
<a name="ml-create-the-web-server-script"></a>

 In diesem Beispiel wird ein Python-Server namens [Flask](https://pypi.org/project/Flask/) verwendet, aber Sie können jeden Webserver verwenden, der für Ihr Framework funktioniert. 

**Anmerkung**  
[Flask](https://pypi.org/project/Flask/) wird hier der Einfachheit halber verwendet. Er gilt nicht als produktionsreifer Webserver.

 Erstellen Sie ein Flask-Webserver-Skript, das die beiden HTTP-Endpunkte auf dem von AI verwendeten TCP-Port 8080 bedient. SageMaker Im Folgenden sind die beiden erwarteten Endpunkte aufgeführt: 
+  `/ping`— SageMaker KI sendet HTTP-GET-Anfragen an diesen Endpunkt, um zu überprüfen, ob Ihr Container bereit ist. Wenn Ihr Container bereit ist, reagiert er auf HTTP-GET-Anfragen an diesem Endpunkt mit einem HTTP 200-Antwortcode. 
+  `/invocations`— SageMaker KI sendet HTTP-POST-Anfragen zur Inferenz an diesen Endpunkt. Die Eingabedaten für die Inferenz werden im Hauptteil der Anfrage gesendet. Der vom Benutzer angegebene Inhaltstyp wird im HTTP-Header übergeben. Der Hauptteil der Antwort ist die Inferenzausgabe. Einzelheiten zu Timeouts finden Sie unter. [Anforderungen und bewährte Verfahren für die Entwicklung von Produkten für maschinelles Lernen](ml-listing-requirements-and-best-practices.md) 

 **`./web_app_serve.py`** 

```
# Import modules
import json
import re
from flask import Flask
from flask import request
app = Flask(__name__)

# Create a path for health checks
@app.route("/ping")
def endpoint_ping():
  return ""
 
# Create a path for inference
@app.route("/invocations", methods=["POST"])
def endpoint_invocations():
  
  # Read the input
  input_str = request.get_data().decode("utf8")
  
  # Add your inference code between these comments.
  #
  #
  #
  #
  #
  # Add your inference code above this comment.
  
  # Return a response with a prediction
  response = {"prediction":"a","text":input_str}
  return json.dumps(response)
```

Im vorherigen Beispiel gibt es keine tatsächliche Inferenzlogik. Fügen Sie für Ihr eigentliches Inferenzbild die Inferenzlogik zur Web-App hinzu, sodass sie die Eingabe verarbeitet und die tatsächliche Vorhersage zurückgibt.

Ihr Inferenzbild muss alle erforderlichen Abhängigkeiten enthalten, da es keinen Internetzugang haben wird und auch keine davon aufrufen kann. AWS-Services

**Anmerkung**  
Derselbe Code wird sowohl für Echtzeit- als auch für Batch-Inferenzen aufgerufen

#### Erstellen Sie das Skript für den Containerlauf
<a name="ml-create-the-script-for-the-container-run"></a>

 Erstellen Sie ein Skript mit dem Namen`serve`, dass SageMaker AI ausgeführt wird, wenn es das Docker-Container-Image ausführt. Das folgende Skript startet den HTTP-Webserver. 

 **`./serve`** 

```
#!/bin/bash

# Run flask server on port 8080 for SageMaker
flask run --host 0.0.0.0 --port 8080
```

#### Erstellen der `Dockerfile`
<a name="ml-create-the-dockerfile"></a>

 Erstellen Sie `Dockerfile` in Ihrem Build-Kontext eine. In diesem Beispiel wird Ubuntu 18.04 verwendet, aber Sie können mit jedem Basis-Image beginnen, das für Ihr Framework funktioniert. 

 `./Dockerfile` 

```
FROM ubuntu:18.04

# Specify encoding
ENV LC_ALL=C.UTF-8
ENV LANG=C.UTF-8

# Install python-pip
RUN apt-get update \
&& apt-get install -y python3.6 python3-pip \
&& ln -s /usr/bin/python3.6 /usr/bin/python \
&& ln -s /usr/bin/pip3 /usr/bin/pip;

# Install flask server
RUN pip install -U Flask;

# Add a web server script to the image
# Set an environment to tell flask the script to run
COPY /web_app_serve.py /web_app_serve.py
ENV FLASK_APP=/web_app_serve.py

# Add a script that Amazon SageMaker AI will run
# Set run permissions
# Prepend program directory to $PATH
COPY /serve /opt/program/serve
RUN chmod 755 /opt/program/serve
ENV PATH=/opt/program:${PATH}
```

 Das `Dockerfile` fügt die beiden zuvor erstellten Skripte zum Image hinzu. Das Verzeichnis des `serve` Skripts wird dem PATH hinzugefügt, sodass es ausgeführt werden kann, wenn der Container ausgeführt wird. 

#### Package oder laden Sie die Modellartefakte hoch
<a name="ml-package-or-upload-the-model-artifacts"></a>

 Es gibt zwei Möglichkeiten, die Modellartefakte vom Trainieren des Modells bis zum Inferenzbild bereitzustellen: 
+  Statisch zusammen mit dem Inferenzbild verpackt. 
+  Wird zur Laufzeit dynamisch geladen. Da es dynamisch geladen wird, können Sie dasselbe Image für die Paketierung verschiedener Machine-Learning-Modelle verwenden.

 Wenn Sie Ihre Modellartefakte zusammen mit dem Inferenzbild verpacken möchten, schließen Sie die Artefakte in das `Dockerfile` ein. 

 Wenn Sie Ihre Modellartefakte dynamisch laden möchten, speichern Sie diese Artefakte separat in einer komprimierten Datei (.tar.gz) in Amazon S3. Geben Sie bei der Erstellung des Modellpakets den Speicherort der komprimierten Datei an. SageMaker AI extrahiert und kopiert den Inhalt in das Container-Verzeichnis, `/opt/ml/model/` wenn Ihr Container ausgeführt wird. Bei der Veröffentlichung Ihres Modellpakets werden diese Artefakte veröffentlicht und in AWS Marketplace eigenen Amazon S3 S3-Buckets gespeichert, auf die der Käufer nicht direkt zugreifen kann. 

### Schritt 2: Erstellen und testen Sie das Image lokal
<a name="ml-step-2-building-and-testing-the-image-locally"></a>

 Im Build-Kontext sind jetzt die folgenden Dateien vorhanden: 
+  `./Dockerfile` 
+  `./web_app_serve.py` 
+  `./serve` 
+  Ihre Inferenzlogik und (optionale) Abhängigkeiten 

 Erstellen Sie als Nächstes das Container-Image, führen Sie es aus und testen Sie es. 

#### Erstellen Sie das Image
<a name="ml-build-the-image"></a>

 Führen Sie den Docker-Befehl im Build-Kontext aus, um das Image zu erstellen und zu taggen. In diesem Beispiel wird das Tag `my-inference-image` verwendet. 

```
sudo docker build --tag my-inference-image ./
```

 Nachdem Sie diesen Docker-Befehl ausgeführt haben, um das Image zu erstellen, sollten Sie die Ausgabe sehen, während Docker das Image auf der Grundlage jeder Zeile in Ihrem erstellt. `Dockerfile` Wenn der Vorgang abgeschlossen ist, sollten Sie etwas Ähnliches wie das Folgende sehen. 

```
Successfully built abcdef123456
Successfully tagged my-inference-image:latest
```

#### Lokales Ausführen von
<a name="ml-run-locally"></a>

 Nachdem Ihr Build abgeschlossen ist, können Sie das Image lokal testen. 

```
sudo docker run \
  --rm \
  --publish 8080:8080/tcp \
  --detach \
  --name my-inference-container \
  my-inference-image \
  serve
```

 Im Folgenden finden Sie Einzelheiten zum Befehl: 
+ `--rm`— Entfernt den Container automatisch, nachdem er gestoppt wurde.
+ `--publish 8080:8080/tcp`— Machen Sie Port 8080 verfügbar, um den Port zu simulieren, an den SageMaker KI HTTP-Anfragen sendet.
+ `--detach`— Führt den Container im Hintergrund aus.
+ `--name my-inference-container`— Geben Sie diesem laufenden Container einen Namen.
+ `my-inference-image`— Führt das erstellte Image aus.
+ `serve`— Führen Sie dasselbe Skript aus, das SageMaker AI beim Ausführen des Containers ausführt.

 Nachdem Sie diesen Befehl ausgeführt haben, erstellt Docker einen Container aus dem von Ihnen erstellten Inferenz-Image und führt ihn im Hintergrund aus. Der Container führt das `serve` Skript aus, das Ihren Webserver zu Testzwecken startet. 

#### Testen Sie den Ping-HTTP-Endpunkt
<a name="ml-test-the-ping-http-endpoint"></a>

 Wenn SageMaker KI Ihren Container ausführt, pingt sie den Endpunkt regelmäßig an. Wenn der Endpunkt eine HTTP-Antwort mit dem Statuscode 200 zurückgibt, signalisiert er der SageMaker KI, dass der Container für die Inferenz bereit ist. Sie können dies testen, indem Sie den folgenden Befehl ausführen, der den Endpunkt testet und den Antwortheader enthält. 

```
curl --include http://127.0.0.1:8080/ping
```

Die Beispielausgabe sieht wie folgt aus.

```
HTTP/1.0 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 0
Server: MyServer/0.16.0 Python/3.6.8
Date: Mon, 21 Oct 2019 06:58:54 GMT
```

#### Testen Sie den HTTP-Endpunkt der Inferenz
<a name="ml-test-the-inference-http-endpoint"></a>

 Wenn der Container anzeigt, dass er bereit ist, indem er einen Statuscode 200 an Ihren Ping zurückgibt, leitet SageMaker AI die Inferenzdaten über eine `POST` Anfrage an den `/invocations` HTTP-Endpunkt weiter. Testen Sie den Inferenzpunkt, indem Sie den folgenden Befehl ausführen. 

```
curl \
  --request POST \
  --data "hello world" \
  http://127.0.0.1:8080/invocations
```

 Die Beispielausgabe sieht wie folgt aus. 

 `{"prediction": "a", "text": "hello world"}` 

 Da diese beiden HTTP-Endpunkte funktionieren, ist das Inferenzbild jetzt mit SageMaker KI kompatibel. 

**Anmerkung**  
 Das Modell Ihres Modellpaketprodukts kann auf zwei Arten bereitgestellt werden: in Echtzeit und im Batch-Modus. In beiden Bereitstellungen verwendet SageMaker KI beim Ausführen des Docker-Containers dieselben HTTP-Endpunkte. 

 Führen Sie den folgenden Befehl aus, um den Container zu beenden.

```
sudo docker container stop my-inference-container
```

 Wenn Ihr Inferenz-Image fertig und getestet ist, können Sie damit [Ihre Bilder in die Amazon Elastic Container Registry hochladen](ml-uploading-your-images.md) fortfahren. 