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.

# Fine-tune öffentlich verfügbare Foundation-Modelle 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 [Fine-tune kuratierte 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 optimieren. SageMaker Python

1. Suchen Sie zunächst in der Tabelle „[Built-in Algorithmen mit vortrainiertem Modell“ nach der Modell-ID für das Modell Ihrer Wahl. ](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.train import ModelTrainer
   from sagemaker.core.jumpstart.configs import JumpStartConfig
   
   jumpstart_config = JumpStartConfig(model_id={{"huggingface-textgeneration1-gpt-j-6b"}})
   model_trainer = ModelTrainer.from_jumpstart_config(jumpstart_config=jumpstart_config)
   ```

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.

   ```
   model_trainer.train(
       input_data_config={"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 vonHugging Face.

   ```
   from sagemaker.serve import ModelBuilder
   
   model_builder = ModelBuilder.from_jumpstart_config(jumpstart_config=jumpstart_config)
   model = model_builder.build()
   endpoint = model_builder.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 = endpoint.invoke(body=question, content_type="text/plain")
   print(response.body.read().decode('utf-8'))
   ```

**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, die 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))
```