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.

# Bereitstellen öffentlich verfügbarer Basismodelle mit der `ModelBuilder`-Klasse
<a name="jumpstart-foundation-models-use-python-sdk-model-class"></a>

Mithilfe des SageMaker Python SDK können Sie in nur wenigen Codezeilen einen integrierten Algorithmus oder ein vortrainiertes Modell auf einem SageMaker KI-Endpunkt bereitstellen.

1. Suchen Sie zunächst die Modell-ID für das Modell Ihrer Wahl unter[Verfügbare Basismodelle](jumpstart-foundation-models-latest.md).

1. Definieren Sie Ihr Modell anhand der Modell-ID als JumpStart Modell.

   ```
   from sagemaker.serve import ModelBuilder
   from sagemaker.core.jumpstart.configs import JumpStartConfig
   
   jumpstart_config = JumpStartConfig(model_id={{"huggingface-text2text-flan-t5-xl"}})
   model_builder = ModelBuilder.from_jumpstart_config(jumpstart_config=jumpstart_config)
   ```

1. Verwenden Sie die `deploy`-Methode, um Ihr Modell automatisch für die Inferenz bereitzustellen. In diesem Beispiel verwenden wir das FLAN-T5 XL-Modell vonHugging Face.

   ```
   model = model_builder.build()
   endpoint = model_builder.deploy()
   ```

1. Anschließend können Sie mithilfe der `invoke` Methode eine Inferenz mit dem bereitgestellten Modell ausführen. Text-generation Modelle wie dieses akzeptieren einen JSON-Anforderungstext mit einem `inputs` Schlüssel. Serialisieren Sie die Nutzlast mit `json.dumps` und setzen Sie den Inhaltstyp auf. `application/json`

   ```
   import json
   
   question = {{"What is Southern California often abbreviated as?"}}
   payload = {"inputs": question, "parameters": {"max_new_tokens": 100}}
   response = endpoint.invoke(body=json.dumps(payload), content_type="application/json")
   print(response.body.read().decode('utf-8'))
   ```

**Anmerkung**  
In diesem Beispiel wird das Foundation-Modell FLAN-T5 XL verwendet, das für eine Vielzahl von Anwendungsfällen zur Textgenerierung geeignet ist, darunter Beantwortung von Fragen, Zusammenfassung, Chatbot-Erstellung und mehr. Weitere Informationen zu Anwendungsfällen für Modelle finden Sie unter [Verfügbare Basismodelle](jumpstart-foundation-models-latest.md).

Weitere Informationen zur `ModelBuilder` Klasse und ihren Parametern finden Sie [ ModelBuilder ](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_serve.html#sagemaker.serve.ModelBuilder) in der SageMaker Python SDK-Dokumentation auf der Read the Docs-Website.

## Standard-Instance-Typen überprüfen
<a name="jumpstart-foundation-models-use-python-sdk-model-class-instance-types"></a>

Wenn Sie ein vortrainiertes Modell bereitstellen, können Sie optional eine Modellversion auf Ihrem `JumpStartConfig` angeben. Sie können auch einen Instanztyp auf Ihrem auswählen `ModelBuilder` (z. B. mit dem `instance_type` Parameter). Alle JumpStart Modelle haben einen Standard-Instanztyp. Rufen Sie den standardmäßigen Bereitstellungs-Instance-Typ mit dem folgenden Code ab:

```
from sagemaker.core import instance_types

instance_type = instance_types.retrieve_default(
    model_id=model_id,
    model_version=model_version,
    scope={{"inference"}})
print(instance_type)
```

Alle unterstützten Instanztypen für ein bestimmtes JumpStart Modell mit der `instance_types.retrieve()` Methode anzeigen.

## Verwenden von Inferenzkomponenten, um mehrere Modelle auf einem gemeinsamen Endpunkt bereitzustellen
<a name="jumpstart-foundation-models-use-python-sdk-model-class-endpoint-types"></a>

Eine Inferenzkomponente ist ein SageMaker KI-Hosting-Objekt, mit dem Sie ein oder mehrere Modelle auf einem Endpunkt bereitstellen können, um die Flexibilität und Skalierbarkeit zu erhöhen. Sie müssen den `endpoint_type` ändern, damit Ihr JumpStart Modell auf Inferenzkomponenten basiert und nicht auf dem standardmäßigen modellbasierten Endpunkt. Import `EndpointType` und Bereitstellung mit dem auf Inferenzkomponenten basierenden Endpunkttyp:

```
from sagemaker.core.enums import EndpointType

endpoint = model_builder.deploy(
    endpoint_name = {{'jumpstart-model-id-123456789012'}}, 
    endpoint_type = EndpointType.INFERENCE_COMPONENT_BASED
)
```

Weitere Informationen zum Erstellen von Endpunkten mit Inferenzkomponenten und zum Bereitstellen von SageMaker KI-Modellen finden Sie unter. [Gemeinsame Ressourcennutzung mit mehreren Modellen](realtime-endpoints-deploy-models.md#deployed-shared-utilization)

## Überprüfen gültiger Eingabe- und Ausgabeinferenzformate
<a name="jumpstart-foundation-models-use-python-sdk-model-class-input-output"></a>

Um gültige Dateneingabe- und -ausgabeformate auf Inferenz zu überprüfen, können Sie die `retrieve_options()`-Methode aus den Klassen `Serializers` und `Deserializers` verwenden.

```
from sagemaker.core.serializers.implementations import retrieve_options as retrieve_serializer_options
from sagemaker.core.deserializers.implementations import retrieve_options as retrieve_deserializer_options

print(retrieve_serializer_options(model_id=model_id, model_version=model_version))
print(retrieve_deserializer_options(model_id=model_id, model_version=model_version))
```

## Überprüfen unterstützter Inhalts- und Annahmetypen
<a name="jumpstart-foundation-models-use-python-sdk-model-class-content-types"></a>

Sie können die `retrieve_options()`-Methode ebenfalls verwenden, um die unterstützten Inhalts- und Annahmetypen zu überprüfen.

```
from sagemaker.core import content_types, accept_types

print(content_types.retrieve_options(model_id=model_id, model_version=model_version))
print(accept_types.retrieve_options(model_id=model_id, model_version=model_version))
```

Weitere Informationen zu Dienstprogrammen finden Sie unter [APIs für Dienstprogramme](https://sagemaker.readthedocs.io/en/stable/api/utility/index.html).