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 eines Multimodell-Endpunkts
<a name="create-multi-model-endpoint"></a>

Sie können die SageMaker AI-Konsole oder die verwenden, AWS SDK für Python (Boto) um einen Endpunkt mit mehreren Modellen zu erstellen. Informationen dazu, wie ein CPU- oder GPU-gestützter Endpunkt über die Konsole erstellt wird, finden Sie im Konsolenverfahren in den folgenden Abschnitten. Wenn Sie mit dem einen Endpunkt mit mehreren Modellen erstellen möchten AWS SDK für Python (Boto), verwenden Sie entweder das CPU- oder GPU-Verfahren in den folgenden Abschnitten. Die CPU- und GPU-Workflows sind ähnlich, weisen jedoch mehrere Unterschiede auf, z. B. die Container-Anforderungen.

**Topics**
+ [Erstellen eines Multimodell-Endpunkts (Konsole)](#create-multi-model-endpoint-console)
+ [Erstellen Sie einen Endpunkt mit mehreren Modellen mithilfe von CPUs AWS SDK für Python (Boto3)](#create-multi-model-endpoint-sdk-cpu)
+ [Erstellen Sie einen Endpunkt mit mehreren Modellen mithilfe von GPUs AWS SDK für Python (Boto3)](#create-multi-model-endpoint-sdk-gpu)

## Erstellen eines Multimodell-Endpunkts (Konsole)
<a name="create-multi-model-endpoint-console"></a>

Über die Konsole können Sie CPU- und GPU-gestützte Multimodell-Endpunkte erstellen. Gehen Sie wie folgt vor, um über die SageMaker AI-Konsole einen Endpunkt mit mehreren Modellen zu erstellen.

**So erstellen Sie einen Multimodell-Endpunkt (Konsole)**

1. Öffnen Sie die Amazon SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

1. Wählen Sie **Model (Modell)** und wählen Sie dann aus der Gruppe **Inference (Inferenz)** die Option **Create model (Modell erstellen)** aus. 

1. Geben Sie für **Model name (Modellname)** einen Namen ein.

1. Wählen Sie für **IAM-Rolle** eine IAM-Rolle bzw. erstellen Sie eine, die mit der `AmazonSageMakerFullAccess` IAM-Richtlinie verknüpft ist. 

1.  Wählen Sie im Abschnitt **Containerdefinition** für **Modellartefakte und Optionen für Inference-Bilder bereitstellen** die Option **Mehrere Modelle verwenden** aus.  
![\[Der Bereich auf der Seite „Modell erstellen“, in dem Sie die Option Mehrere Modelle verwenden auswählen können\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/mme-create-model-ux-2.PNG)

1. Geben Sie für das **Inference-Container-Image** den Amazon ECR-Pfad für Ihr gewünschtes Container-Image ein.

   Für GPU-Modelle müssen Sie einen Container verwenden, der vom NVIDIA Triton Inference Server unterstützt wird. Eine Liste der Container-Images, die mit GPU-gestützten Endpunkten funktionieren, finden Sie in den [NVIDIA Triton Inference Containers (nur SM-Unterstützung)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only). Weitere Informationen zum NVIDIA Triton Inference Server finden Sie unter [Verwenden von Triton Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) Server mit KI. SageMaker 

1. Wählen Sie **Modell erstellen** aus.

1. Stellen Sie Ihren Multimodell-Endpunkt genauso wie einen Einzelmodell-Endpunkt bereit. Detaillierte Anweisungen finden Sie unter [Stellen Sie das Modell für SageMaker AI Hosting Services bereit](ex1-model-deployment.md#ex1-deploy-model).

## Erstellen Sie einen Endpunkt mit mehreren Modellen mithilfe von CPUs AWS SDK für Python (Boto3)
<a name="create-multi-model-endpoint-sdk-cpu"></a>

Erstellen Sie mit Hilfe des folgenden Abschnitts einen durch CPU-Instances unterstützten Multimodell-Endpunkt. Sie erstellen mithilfe der Amazon SageMaker AI einen Endpunkt mit mehreren Modellen [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model), und zwar [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs genau so [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config), als würden Sie einen Endpunkt mit einem einzigen Modell erstellen, jedoch mit zwei Änderungen. Wenn Sie den Container für das Modell definieren, müssen Sie einen neuen `Mode`-Parameterwert übergeben, `MultiModel`. Sie müssen auch das Feld `ModelDataUrl` übergeben, das das Präfix in Amazon S3 angibt, in dem sich die Modellartefakte befinden, anstatt den Pfad zu einem Artefakt mit nur einem Modell, wie beim Bereitstellen eines einzelnen Modells.

Ein Beispiel-Notizbuch, das SageMaker KI verwendet, um mehrere XGBoost Modelle auf einem Endpunkt bereitzustellen, finden Sie unter [ XGBoost Beispielnotizbuch für Endgeräte mit mehreren Modellen](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/multi_model_xgboost_home_value/xgboost_multi_model_endpoint_home_value.html). 

Im folgenden Verfahren werden die wichtigsten Schritte beschrieben, die in diesem Beispiel zum Erstellen eines Multimodell-Endpunkts mit CPU-Unterstützung verwendet werden.

**Um das Modell bereitzustellen (AWS SDK für Python (Boto 3))**

1. Besorgen Sie sich einen Container mit einem Image, das die Bereitstellung von Multimodell-Endpunkten unterstützt. Eine Liste der integrierten Algorithmen und Framework-Container, die Multimodell-Endpunkte unterstützen, finden Sie unter [Unterstützte Algorithmen, Frameworks und Instances für Multimodell-Endpunkte](multi-model-support.md). In diesem Beispiel verwenden wir den integrierten Algorithmus [K-nearest neighbors (k-NN)-Algorithmus](k-nearest-neighbors.md). Wir rufen die [SageMaker Python-SDK-Utility-Funktion](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` auf, um die Adresse für das integrierte K-Nearest Neighbors-Algorithmus-Image abzurufen.

   ```
   import sagemaker
   region = sagemaker_session.boto_region_name
   image = sagemaker.image_uris.retrieve("knn",region=region)
   container = { 
                 'Image':        image,
                 'ModelDataUrl': 's3://<BUCKET_NAME>/<PATH_TO_ARTIFACTS>',
                 'Mode':         'MultiModel'
               }
   ```

1. Holen Sie sich einen AWS SDK für Python (Boto3) SageMaker AI-Client und erstellen Sie das Modell, das diesen Container verwendet.

   ```
   import boto3
   sagemaker_client = boto3.client('sagemaker')
   response = sagemaker_client.create_model(
                 ModelName        = '<MODEL_NAME>',
                 ExecutionRoleArn = role,
                 Containers       = [container])
   ```

1. (Optional) Wenn Sie eine serielle Inferenz-Pipeline verwenden, rufen Sie die zusätzlichen Container ab, die in der Pipeline enthalten sein sollen, und fügen sie in das Argument `Containers` von `CreateModel` ein:

   ```
   preprocessor_container = { 
                  'Image': '<ACCOUNT_ID>.dkr.ecr.<REGION_NAME>.amazonaws.com/<PREPROCESSOR_IMAGE>:<TAG>'
               }
   
   multi_model_container = { 
                 'Image': '<ACCOUNT_ID>.dkr.ecr.<REGION_NAME>.amazonaws.com/<IMAGE>:<TAG>',
                 'ModelDataUrl': 's3://<BUCKET_NAME>/<PATH_TO_ARTIFACTS>',
                 'Mode':         'MultiModel'
               }
   
   response = sagemaker_client.create_model(
                 ModelName        = '<MODEL_NAME>',
                 ExecutionRoleArn = role,
                 Containers       = [preprocessor_container, multi_model_container]
               )
   ```
**Anmerkung**  
Sie können nur einen multi-model-enabled Endpunkt in einer seriellen Inferenzpipeline verwenden.

1. (Optional) Wenn Ihr Anwendungsfall vom Modell-Caching nicht profitiert, setzen Sie den Wert des Feldes `ModelCacheSetting` des Parameters `MultiModelConfig` auf `Disabled` und nehmen Sie ihn in das Argument `Container` des Aufrufs von `create_model` auf. Der Wert für das Feld `ModelCacheSetting` ist standardmäßig `Enabled`.

   ```
   container = { 
                   'Image': image, 
                   'ModelDataUrl': 's3://<BUCKET_NAME>/<PATH_TO_ARTIFACTS>',
                   'Mode': 'MultiModel' 
                   'MultiModelConfig': {
                           // Default value is 'Enabled'
                           'ModelCacheSetting': 'Disabled'
                   }
              }
   
   response = sagemaker_client.create_model(
                 ModelName        = '<MODEL_NAME>',
                 ExecutionRoleArn = role,
                 Containers       = [container]
               )
   ```

1. Konfigurieren Sie den Multimodell-Endpunkt für das Modell. Wir empfehlen, Ihre Endpunkte mit mindestens zwei Instances zu konfigurieren. Auf diese Weise kann SageMaker KI für die Modelle einen hochverfügbaren Satz von Vorhersagen über mehrere Availability Zones hinweg bereitstellen.

   ```
   response = sagemaker_client.create_endpoint_config(
                   EndpointConfigName = '<ENDPOINT_CONFIG_NAME>',
                   ProductionVariants=[
                        {
                           'InstanceType':        'ml.m4.xlarge',
                           'InitialInstanceCount': 2,
                           'InitialVariantWeight': 1,
                           'ModelName':            '<MODEL_NAME>',
                           'VariantName':          'AllTraffic'
                         }
                   ]
              )
   ```
**Anmerkung**  
Sie können nur einen multi-model-enabled Endpunkt in einer seriellen Inferenzpipeline verwenden.

1. Erstellen Sie den Multimodell-Endpunkt mit den Parametern `EndpointName` und `EndpointConfigName`.

   ```
   response = sagemaker_client.create_endpoint(
                 EndpointName       = '<ENDPOINT_NAME>',
                 EndpointConfigName = '<ENDPOINT_CONFIG_NAME>')
   ```

## Erstellen Sie einen Endpunkt mit mehreren Modellen mithilfe von GPUs AWS SDK für Python (Boto3)
<a name="create-multi-model-endpoint-sdk-gpu"></a>

Erstellen Sie mit Hilfe des folgenden Abschnitts einen durch GPU unterstützten Multimodell-Endpunkt. Sie erstellen einen Endpunkt mit mehreren Modellen mithilfe der Amazon SageMaker AI [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model)und [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) APIs ähnlich wie bei der Erstellung von Einzelmodell-Endpunkten, es gibt jedoch mehrere Änderungen. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) Wenn Sie den Container für das Modell definieren, müssen Sie einen neuen `Mode`-Parameterwert übergeben, `MultiModel`. Sie müssen auch das Feld `ModelDataUrl` übergeben, das das Präfix in Amazon S3 angibt, in dem sich die Modellartefakte befinden, anstatt den Pfad zu einem Artefakt mit nur einem Modell, wie beim Bereitstellen eines einzelnen Modells. Für GPU-gestützte Multimodell-Endpunkte müssen Sie außerdem einen Container mit dem NVIDIA Triton Inference Server verwenden, der für die Ausführung auf GPU-Instances optimiert ist. Eine Liste der Container-Images, die mit GPU-gestützten Endpunkten funktionieren, finden Sie in den [NVIDIA Triton Inference Containers (nur SM-Unterstützung)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only).

Ein Beispiel-Notizbuch, das zeigt, wie Sie einen Multi-Modell-Endpoint erstellen, der von unterstützt wird GPUs, finden Sie unter [Ausführen mehrerer Deep-Learning-Modelle auf GPUs Amazon SageMaker AI Multi-Model Endpoints](https://github.com/aws/amazon-sagemaker-examples/blob/main/multi-model-endpoints/mme-on-gpu/cv/resnet50_mme_with_gpu.ipynb) (MME).

Das folgende Verfahren beschreibt die wichtigsten Schritte zur Erstellung eines GPU-gestützten Multimodell-Endpunkts.

**Um das Modell bereitzustellen (AWS SDK für Python (Boto 3))**

1. Definieren Sie das Container-Image. Um einen Endpunkt mit mehreren Modellen mit GPU-Unterstützung für ResNet Modelle zu erstellen, definieren Sie den Container so, dass er das [NVIDIA Triton Server-Image](https://docs.aws.amazon.com/sagemaker/latest/dg/triton.html) verwendet. Dieser Container unterstützt Multimodell-Endpunkte und ist für die Ausführung auf GPU-Instances optimiert. Wir rufen die [SageMaker AI Python SDK-Utility-Funktion](https://sagemaker.readthedocs.io/en/stable/v2.html) `image_uris.retrieve()` auf, um die Adresse für das Bild abzurufen. Beispiel:

   ```
   import sagemaker
   region = sagemaker_session.boto_region_name
   
   // Find the sagemaker-tritonserver image at 
   // https://github.com/aws/amazon-sagemaker-examples/blob/main/sagemaker-triton/resnet50/triton_resnet50.ipynb
   // Find available tags at https://github.com/aws/deep-learning-containers/blob/master/available_images.md#nvidia-triton-inference-containers-sm-support-only
   
   image = "<ACCOUNT_ID>.dkr.ecr.<REGION_NAME>.amazonaws.com/sagemaker-tritonserver:<TAG>".format(
       account_id=account_id_map[region], region=region
   )
   
   container = { 
                 'Image':        image,
                 'ModelDataUrl': 's3://<BUCKET_NAME>/<PATH_TO_ARTIFACTS>',
                 'Mode':         'MultiModel',
                 "Environment": {"SAGEMAKER_TRITON_DEFAULT_MODEL_NAME": "resnet"},
               }
   ```

1. Holen Sie sich einen AWS SDK für Python (Boto3) SageMaker AI-Client und erstellen Sie das Modell, das diesen Container verwendet.

   ```
   import boto3
   sagemaker_client = boto3.client('sagemaker')
   response = sagemaker_client.create_model(
                 ModelName        = '<MODEL_NAME>',
                 ExecutionRoleArn = role,
                 Containers       = [container])
   ```

1. (Optional) Wenn Sie eine serielle Inferenz-Pipeline verwenden, rufen Sie die zusätzlichen Container ab, die in der Pipeline enthalten sein sollen, und fügen sie in das Argument `Containers` von `CreateModel` ein:

   ```
   preprocessor_container = { 
                  'Image': '<ACCOUNT_ID>.dkr.ecr.<REGION_NAME>.amazonaws.com/<PREPROCESSOR_IMAGE>:<TAG>'
               }
   
   multi_model_container = { 
                 'Image': '<ACCOUNT_ID>.dkr.ecr.<REGION_NAME>.amazonaws.com/<IMAGE>:<TAG>',
                 'ModelDataUrl': 's3://<BUCKET_NAME>/<PATH_TO_ARTIFACTS>',
                 'Mode':         'MultiModel'
               }
   
   response = sagemaker_client.create_model(
                 ModelName        = '<MODEL_NAME>',
                 ExecutionRoleArn = role,
                 Containers       = [preprocessor_container, multi_model_container]
               )
   ```
**Anmerkung**  
Sie können nur einen multi-model-enabled Endpunkt in einer seriellen Inferenzpipeline verwenden.

1. (Optional) Wenn Ihr Anwendungsfall vom Modell-Caching nicht profitiert, setzen Sie den Wert des Feldes `ModelCacheSetting` des Parameters `MultiModelConfig` auf `Disabled` und nehmen Sie ihn in das Argument `Container` des Aufrufs von `create_model` auf. Der Wert für das Feld `ModelCacheSetting` ist standardmäßig `Enabled`.

   ```
   container = { 
                   'Image': image, 
                   'ModelDataUrl': 's3://<BUCKET_NAME>/<PATH_TO_ARTIFACTS>',
                   'Mode': 'MultiModel' 
                   'MultiModelConfig': {
                           // Default value is 'Enabled'
                           'ModelCacheSetting': 'Disabled'
                   }
              }
   
   response = sagemaker_client.create_model(
                 ModelName        = '<MODEL_NAME>',
                 ExecutionRoleArn = role,
                 Containers       = [container]
               )
   ```

1. Konfigurieren Sie den Multimodell-Endpunkt mit GPU-gestützten Instances für das Modell. Wir empfehlen, Ihre Endpunkte mit mehr als einer Instance zu konfigurieren, um eine hohe Verfügbarkeit und höhere Cache-Zugriffe zu gewährleisten.

   ```
   response = sagemaker_client.create_endpoint_config(
                   EndpointConfigName = '<ENDPOINT_CONFIG_NAME>',
                   ProductionVariants=[
                        {
                           'InstanceType':        'ml.g4dn.4xlarge',
                           'InitialInstanceCount': 2,
                           'InitialVariantWeight': 1,
                           'ModelName':            '<MODEL_NAME>',
                           'VariantName':          'AllTraffic'
                         }
                   ]
              )
   ```

1. Erstellen Sie den Multimodell-Endpunkt mit den Parametern `EndpointName` und `EndpointConfigName`.

   ```
   response = sagemaker_client.create_endpoint(
                 EndpointName       = '<ENDPOINT_NAME>',
                 EndpointConfigName = '<ENDPOINT_CONFIG_NAME>')
   ```