

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.

# Verwenden Sie Foundation-Modelle mit dem SDK SageMaker Python
<a name="jumpstart-foundation-models-use-python-sdk"></a>

Alle JumpStart Foundation-Modelle sind für die programmatische Bereitstellung mithilfe des SageMaker Python SDK verfügbar.

Um öffentlich verfügbare Basismodelle bereitzustellen, können Sie deren Modell-ID verwenden. Sie finden das Modell IDs für alle öffentlich verfügbaren Foundation-Modelle in der Tabelle mit [integrierten Algorithmen mit vortrainiertem Modell](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html). Suchen Sie in der **Suchleiste** nach dem Namen eines Basismodells. Verwenden Sie das Drop-down-Menü **Einträge anzeigen** oder die Seitennummerierung, um durch die verfügbaren Modelle zu navigieren.

Proprietäre Modelle müssen nach dem Abonnieren des Modells in AWS Marketplace unter Verwendung der Modellpaketinformationen bereitgestellt werden. 

Die Liste der JumpStart verfügbaren Modelle finden Sie unter[Verfügbare Basismodelle](jumpstart-foundation-models-latest.md).

**Wichtig**  
Einige Grundlagenmodelle erfordern die ausdrückliche Annahme einer Endbenutzer-Lizenzvereinbarung (EULA). Weitere Informationen finden Sie unter [Annahme der EULA mit dem SDK SageMaker Python](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula-python-sdk).

In den folgenden Abschnitten wird gezeigt, wie öffentlich verfügbare Basismodelle mithilfe der `JumpStartEstimator`-Klasse optimiert werden und wie öffentlich verfügbare Basismodelle mithilfe der `JumpStartModel`-Klasse und proprietäre Basismodelle mithilfe der `ModelPackage`-Klasse bereitgestellt werden.

**Topics**
+ [Optimieren von öffentlich verfügbaren Basismodellen mit der `JumpStartEstimator`-Klasse](jumpstart-foundation-models-use-python-sdk-estimator-class.md)
+ [Bereitstellen öffentlich verfügbarer Basismodelle mit der `JumpStartModel`-Klasse](jumpstart-foundation-models-use-python-sdk-model-class.md)
+ [Bereitstellen proprietärer Basismodelle mit der `ModelPackage`-Klasse](jumpstart-foundation-models-use-python-sdk-proprietary.md)

# Optimieren von öffentlich verfügbaren Basismodellen mit der `JumpStartEstimator`-Klasse
<a name="jumpstart-foundation-models-use-python-sdk-estimator-class"></a>

**Anmerkung**  
Anweisungen zur Optimierung von Basismodellen in einem privaten, kuratierten Hub finden Sie unter [Optimieren kuratierter Hub-Modelle](jumpstart-curated-hubs-fine-tune.md).

Mithilfe des SDK können Sie einen integrierten Algorithmus oder ein vortrainiertes Modell in nur wenigen Codezeilen feinabstimmen. SageMaker Python

1. Suchen Sie zunächst die Modell-ID für das Modell Ihrer Wahl in der Tabelle [In vortrainierte Modelle integrierte Algorithmen](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html). 

1. Definieren Sie anhand der Modell-ID Ihren Trainingsjob als JumpStart Schätzer.

   ```
   from sagemaker.jumpstart.estimator import JumpStartEstimator
   
   model_id = "huggingface-textgeneration1-gpt-j-6b"
   estimator = JumpStartEstimator(model_id=model_id)
   ```

1. Führen Sie `estimator.fit()` auf Ihrem Modell aus und verweisen Sie dabei auf die Trainingsdaten, die für die Optimierung verwendet werden sollen.

   ```
   estimator.fit(
       {"train": training_dataset_s3_path, "validation": validation_dataset_s3_path}
   )
   ```

1. Verwenden Sie dann die `deploy`-Methode, um Ihr Modell automatisch für die Inferenz bereitzustellen. In diesem Beispiel verwenden wir das GPT-J-6B-Modell von Hugging Face.

   ```
   predictor = estimator.deploy()
   ```

1. Anschließend können Sie mit der `predict`-Methode eine Inferenz mit dem bereitgestellten Modell ausführen.

   ```
   question = "What is Southern California often abbreviated as?"
   response = predictor.predict(question)
   print(response)
   ```

**Anmerkung**  
In diesem Beispiel wird das Basismodell GPT-J 6B verwendet, das für eine Vielzahl von Anwendungsfällen zur Textgenerierung geeignet ist, darunter die Beantwortung von Fragen, Erkennung benannter Entitäten, Zusammenfassung und mehr. Weitere Informationen zu Anwendungsfällen für Modelle finden Sie unter [Verfügbare Basismodelle](jumpstart-foundation-models-latest.md).

Sie können optional Modellversionen oder Instance-Typen angeben, wenn Sie Ihren `JumpStartEstimator` erstellen. Weitere Hinweise zur `JumpStartEstimator ` Klasse und ihren Parametern finden Sie unter [JumpStartEstimator](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.jumpstart.estimator.JumpStartEstimator).

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

Sie können bei der Optimierung eines vortrainierten Modells mithilfe der `JumpStartEstimator`-Klasse optional bestimmte Modellversionen oder Instance-Typen einbeziehen. Alle JumpStart Modelle haben einen Standard-Instanztyp. Rufen Sie den standardmäßigen Trainings-Instance-Typ mit dem folgenden Code ab:

```
from sagemaker import instance_types

instance_type = instance_types.retrieve_default(
    model_id=model_id,
    model_version=model_version,
    scope="training")
print(instance_type)
```

Mit der `instance_types.retrieve()` Methode können Sie alle unterstützten Instanztypen für ein bestimmtes JumpStart Modell anzeigen.

## Standard-Hyperparameter überprüfen
<a name="jumpstart-foundation-models-use-python-sdk-estimator-class-hyperparameters"></a>

Um die für das Training verwendeten Standard-Hyperparameter zu überprüfen, können Sie die `retrieve_default()`-Methode aus der `hyperparameters`-Klasse verwenden.

```
from sagemaker import hyperparameters

my_hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)
print(my_hyperparameters)

# Optionally override default hyperparameters for fine-tuning
my_hyperparameters["epoch"] = "3"
my_hyperparameters["per_device_train_batch_size"] = "4"

# Optionally validate hyperparameters for the model
hyperparameters.validate(model_id=model_id, model_version=model_version, hyperparameters=my_hyperparameters)
```

Weitere Informationen über verfügbare Hyperparameter finden Sie unter [Häufig unterstützte Hyperparameter bei der Optimierung](jumpstart-foundation-models-fine-tuning.md#jumpstart-foundation-models-fine-tuning-hyperparameters).

## Standard-Metrikdefinitionen überprüfen
<a name="jumpstart-foundation-models-use-python-sdk-estimator-class-metric-definitions"></a>

Sie können auch die standardmäßigen Metrikdefinitionen überprüfen:

```
print(metric_definitions.retrieve_default(model_id=model_id, model_version=model_version))
```

# Bereitstellen öffentlich verfügbarer Basismodelle mit der `JumpStartModel`-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 in der Tabelle [In vortrainierte Modelle integrierte Algorithmen](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html).

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

   ```
   from sagemaker.jumpstart.model import JumpStartModel
   
   model_id = "huggingface-text2text-flan-t5-xl"
   my_model = JumpStartModel(model_id=model_id)
   ```

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

   ```
   predictor = my_model.deploy()
   ```

1. Anschließend können Sie mit der `predict`-Methode eine Inferenz mit dem bereitgestellten Modell ausführen.

   ```
   question = "What is Southern California often abbreviated as?"
   response = predictor.predict(question)
   print(response)
   ```

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

Weitere Informationen zur `JumpStartModel ` Klasse und ihren Parametern finden Sie unter [JumpStartModel](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.jumpstart.model.JumpStartModel).

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

Sie können bei der Bereitstellung eines vortrainierten Modells mithilfe der `JumpStartModel`-Klasse optional bestimmte Modellversionen oder Instance-Typen einbeziehen. Alle JumpStart Modelle haben einen Standard-Instanztyp. Rufen Sie den standardmäßigen Bereitstellungs-Instance-Typ mit dem folgenden Code ab:

```
from sagemaker import instance_types

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

Mit der `instance_types.retrieve()` Methode werden alle unterstützten Instanztypen für ein bestimmtes JumpStart Modell angezeigt.

## 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 das ändern, `endpoint_type` damit Ihr JumpStart Modell inference-component-based nicht mehr der standardmäßige modellbasierte Endpunkt ist. 

```
predictor = my_model.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.

```
print(sagemaker.serializers.retrieve_options(model_id=model_id, model_version=model_version))
print(sagemaker.deserializers.retrieve_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.

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

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

# Bereitstellen proprietärer Basismodelle mit der `ModelPackage`-Klasse
<a name="jumpstart-foundation-models-use-python-sdk-proprietary"></a>

Proprietäre Modelle müssen nach dem Abonnieren des Modells in AWS Marketplace unter Verwendung der Modellpaketinformationen bereitgestellt werden. Weitere Informationen zu SageMaker KI und AWS Marketplace finden Sie unter [Amazon SageMaker AI-Algorithmen und -Modelle kaufen und verkaufen unter AWS Marketplace](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-marketplace.html). AWS Marketplace Links zu den neuesten proprietären Modellen finden Sie unter [Erste Schritte mit Amazon SageMaker JumpStart](https://aws.amazon.com/sagemaker/jumpstart/getting-started/?sagemaker-jumpstart-cards.sort-by=item.additionalFields.priority&sagemaker-jumpstart-cards.sort-order=asc&awsf.sagemaker-jumpstart-filter-product-type=product-type%23foundation-model&awsf.sagemaker-jumpstart-filter-text=*all&awsf.sagemaker-jumpstart-filter-vision=*all&awsf.sagemaker-jumpstart-filter-tabular=*all&awsf.sagemaker-jumpstart-filter-audio-tasks=*all&awsf.sagemaker-jumpstart-filter-multimodal=*all&awsf.sagemaker-jumpstart-filter-RL=*all&sagemaker-jumpstart-cards.q=proprietary&sagemaker-jumpstart-cards.q_operator=AND).

Nachdem Sie das Modell Ihrer Wahl abonniert haben AWS Marketplace, können Sie das Foundation-Modell mithilfe des SageMaker Python SDK und des mit dem Modellanbieter verknüpften SDK bereitstellen. Verwenden Sie beispielsweise AI21 Labs, Cohere und LightOn verwenden Sie die `lightonsage` Pakete `"ai21[SM]"``cohere-sagemaker`,, und.

Um beispielsweise ein JumpStart Modell mit Jurassic-2 Jumbo Instruct von AI21 Labs zu definieren, verwenden Sie den folgenden Code: 

```
import sagemaker
import ai21

role = get_execution_role()
sagemaker_session = sagemaker.Session()
model_package_arn = "arn:aws:sagemaker:us-east-1:865070037744:model-package/j2-jumbo-instruct-v1-1-43-4e47c49e61743066b9d95efed6882f35"

my_model = ModelPackage(
    role=role, model_package_arn=model_package_arn, sagemaker_session=sagemaker_session
)
```

Suchen Sie step-by-step beispielsweise in Studio Classic nach dem Notizbuch, das dem proprietären Foundation-Modell Ihrer Wahl zugeordnet ist, und führen Sie es aus. SageMaker Weitere Informationen finden Sie unter [Verwenden Sie Fundamentmodelle in Amazon SageMaker Studio Classic](jumpstart-foundation-models-use-studio.md). Weitere Informationen zum SageMaker Python SDK finden Sie unter [https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.model.ModelPackage](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.model.ModelPackage).