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.
# Modelle SageMaker JumpStart der Amazon Foundation
Amazon SageMaker JumpStart bietet state-of-the-art Basismodelle für Anwendungsfälle wie das Schreiben von Inhalten, Codegenerierung, Beantwortung von Fragen, Verfassen von Texten, Zusammenfassen, Klassifizieren, Abrufen von Informationen und mehr. Verwenden Sie JumpStart Basismodelle, um Ihre eigenen generativen KI-Lösungen zu entwickeln und benutzerdefinierte Lösungen mit zusätzlichen SageMaker KI-Funktionen zu integrieren. Weitere Informationen finden Sie unter [Erste Schritte mit Amazon SageMaker JumpStart](https://aws.amazon.com/sagemaker/jumpstart/getting-started/).
Ein Grundlagenmodell ist ein umfangreiches, vortrainiertes Modell, das sich an viele nachgelagerte Aufgaben anpassen lässt und häufig als Ausgangspunkt für die Entwicklung spezialisierterer Modelle dient. Beispiele für Basismodelle sind LLa MA-3-70b, BLOOM 176B, FLAN-T5 XL oder GPT-J 6B, die für riesige Textdatenmengen vorab trainiert wurden und für spezifische Sprachaufgaben optimiert werden können.
Amazon integriert und SageMaker JumpStart verwaltet öffentlich verfügbare Basismodelle, auf die Sie zugreifen, sie anpassen und in Ihre Lebenszyklen für maschinelles Lernen integrieren können. Weitere Informationen finden Sie unter [Öffentlich verfügbare Grundlagenmodelle](jumpstart-foundation-models-latest.md#jumpstart-foundation-models-latest-publicly-available). Amazon bietet SageMaker JumpStart auch proprietäre Gründungsmodelle von Drittanbietern an. Weitere Informationen finden Sie unter [Proprietäre Grundlagenmodelle](jumpstart-foundation-models-latest.md#jumpstart-foundation-models-latest-proprietary).
Informationen zu den ersten Schritten beim Erkunden und Experimentieren mit verfügbaren Modellen finden Sie unter [JumpStart Verwendung des Foundation-Modells](jumpstart-foundation-models-use.md). Alle Foundation-Modelle können programmgesteuert mit dem SageMaker Python SDK verwendet werden. Weitere Informationen finden Sie unter [Verwenden Sie Foundation-Modelle mit dem SDK SageMaker Python](jumpstart-foundation-models-use-python-sdk.md).
Weitere Informationen zu den Überlegungen, die bei der Auswahl eines Modells zu berücksichtigen sind, finden Sie unter [Modellquellen und Lizenzvereinbarungen](jumpstart-foundation-models-choose.md).
Einzelheiten zur Anpassung und Feinabstimmung von Grundlagenmodellen finden Sie unter [Anpassung des Basismodells](jumpstart-foundation-models-customize.md).
Weitere allgemeine Informationen zu Grundlagenmodellen finden Sie im Artikel [On the Opportunities and Risks of Foundation Models](https://arxiv.org/abs/2108.07258) über die Chancen und Risiken von Grundlagenmodellen.
**Topics**
+ [Verfügbare Basismodelle](jumpstart-foundation-models-latest.md)
+ [JumpStart Verwendung des Foundation-Modells](jumpstart-foundation-models-use.md)
+ [Modellquellen und Lizenzvereinbarungen](jumpstart-foundation-models-choose.md)
+ [Anpassung des Basismodells](jumpstart-foundation-models-customize.md)
+ [Bewerten eines Basismodells für die Textgenerierung in Studio](jumpstart-foundation-models-evaluate.md)
+ [Beispiel-Notebooks](jumpstart-foundation-models-example-notebooks.md)
# Verfügbare Basismodelle
Amazon SageMaker JumpStart bietet integrierte state-of-the-art, öffentlich verfügbare und proprietäre Basismodelle zur Anpassung und Integration in Ihre generativen KI-Workflows.
## Öffentlich verfügbare Grundlagenmodelle
Amazon SageMaker JumpStart integriert und verwaltet Open-Source-Foundation-Modelle von Drittanbietern. Um eines dieser öffentlich verfügbaren Modelle erstmals zu verwenden, sehen Sie sich [JumpStart Verwendung des Foundation-Modells](jumpstart-foundation-models-use.md) oder eines der verfügbaren [Beispiel-Notebooks](jumpstart-foundation-models-example-notebooks.md) an. Versuchen Sie, in einem Beispiel-Notebook für ein öffentlich verfügbares Modell die Modell-ID auszutauschen, um mit verschiedenen Modellen innerhalb derselben Modellfamilie zu experimentieren.
Weitere Informationen zu Modellen IDs und Ressourcen für die Bereitstellung öffentlich verfügbarer JumpStart Foundation-Modelle mit dem SageMaker Python SDK finden Sie unter[Verwenden Sie Foundation-Modelle mit dem SDK SageMaker Python](jumpstart-foundation-models-use-python-sdk.md).
Definitionsgemäß sind Grundlagenmodelle an viele nachgelagerte Aufgaben anpassbar. Grundlagenmodelle werden mit riesigen Mengen allgemeiner Domaindaten trainiert. Zudem kann dasselbe Modell für mehrere Anwendungsfälle implementiert oder angepasst werden. Beginnen Sie bei der Auswahl Ihres Basismodells mit der Definition einer bestimmten Aufgabe, wie der Textgenerierung oder Bildgenerierung.
### Öffentlich verfügbare Zeitreihen-Prognosemodelle
Zeitreihen-Prognosemodelle dienen dazu, sequentielle Daten im Zeitverlauf zu analysieren und Vorhersagen zu treffen. Diese Modelle können auf verschiedene Bereiche wie Finanzen, Wettervorhersagen oder Energiebedarfsprognosen angewendet werden. Die Chronos-Modelle sind auf Aufgaben zur Vorhersage von Zeitreihen zugeschnitten und ermöglichen genaue Vorhersagen auf der Grundlage historischer Datenmuster.
| Modellname | Modell-ID | Modellquelle | Optimierbar |
| --- | --- | --- | --- |
| Chronos T5 Small | autogluon-forecasting-chronos-t5-small | Amazon | Nein |
| Chronos T5 Base | autogluon-forecasting-chronos-t5-base | Amazon | Nein |
| Chronos T5 Large | autogluon-forecasting-chronos-t5-large | Amazon | Nein |
| Chronos-Bolt Small | autogluon-forecasting-chronos-bolt-small | Amazon | Nein |
| Chronos-Bolt Base | autogluon-forecasting-chronos-bolt-base | Amazon | Nein |
### Öffentlich verfügbare Modelle zur Textgenerierung
Grundlagenmodelle für die Textgenerierung können für eine Vielzahl nachgelagerter Aufgaben verwendet werden, darunter Textzusammenfassung, Textklassifizierung, Beantwortung von Fragen, Generierung von Inhalten in Langform, Verfassen von Kurztexten, Informationsextraktion und mehr.
Verwenden Sie den Filter Textgenerierung auf JumpStart der SageMaker JumpStart Produktbeschreibungsseite [Erste Schritte mit Amazon](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=ml-task-type%23text-generation&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&awsm.page-sagemaker-jumpstart-cards=1), um die neuesten Basismodelle für die **Textgenerierung** zu erkunden. Sie können Fundamentmodelle, die auf Aufgaben basieren, auch direkt in der Amazon SageMaker Studio-Benutzeroberfläche oder der SageMaker Studio Classic-Benutzeroberfläche erkunden. Nur eine Teilmenge der öffentlich verfügbaren Textgenerierungsmodelle steht für die Feinabstimmung zur Verfügung. JumpStart Weitere Informationen finden Sie unter [Verwenden Sie Fundamentmodelle in Amazon SageMaker Studio Classic](jumpstart-foundation-models-use-studio.md).
### Öffentlich verfügbare Modelle zur Bilderzeugung
JumpStart bietet eine Vielzahl von Basismodellen für die Bilderzeugung mit stabiler Diffusion, darunter Basismodelle von Stability AI sowie vortrainierte Modelle für spezifische text-to-image Aufgaben vonHugging Face. Wenn Sie Ihr text-to-image Basismodell verfeinern müssen, können Sie Stable Diffusion 2.1 Base von Stability AI verwenden. Wenn Sie Modelle erkunden möchten, die bereits in bestimmten Kunststilen geschult sind, können Sie eines der vielen Modelle von Drittanbietern Hugging Face direkt in der Amazon SageMaker Studio-Benutzeroberfläche oder der SageMaker Studio Classic-Benutzeroberfläche erkunden.
Verwenden Sie den **Text-zu-Bild-Filter auf der SageMaker JumpStart Produktbeschreibungsseite [Erste Schritte mit Amazon](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=ml-task-type%23txt2img&awsf.sagemaker-jumpstart-filter-RL=*all&awsm.page-sagemaker-jumpstart-cards=1), um die neuesten Basismodelle für die Bildgenerierung JumpStart ** zu erkunden. Informationen zu den ersten Schritten mit dem von Ihnen ausgewählten text-to-image Fundamentmodell finden Sie unter[JumpStart Verwendung des Foundation-Modells](jumpstart-foundation-models-use.md).
## Proprietäre Grundlagenmodelle
Amazon SageMaker JumpStart bietet Zugriff auf proprietäre Fundamentmodelle von Drittanbietern wie [AI21 Labs](https://www.ai21.com/), [Cohere](https://cohere.com/) und [LightOn](https://www.lighton.ai/).
Informationen zu den ersten Schritten mit einem dieser proprietären Modelle finden Sie unter [JumpStart Verwendung des Foundation-Modells](jumpstart-foundation-models-use.md). Um ein proprietäres Grundlagenmodell verwenden zu können, müssen Sie das Modell zunächst unter AWS Marketplace abonnieren. Nachdem Sie das Modell abonniert haben, suchen Sie das Foundation-Modell in Studio oder SageMaker Studio Classic. Weitere Informationen finden Sie unter [SageMaker JumpStart vortrainierte Modelle](studio-jumpstart.md).
Informationen zu den neuesten proprietären Basismodellen für eine Vielzahl von Anwendungsfällen 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).
# JumpStart Verwendung des Foundation-Modells
Wählen, trainieren oder implementieren Sie Foundation-Modelle über Amazon SageMaker Studio oder Amazon SageMaker Studio Classic, verwenden Sie JumpStart Foundation-Modelle programmgesteuert mit dem SageMaker Python SDK oder entdecken Sie JumpStart Foundation-Modelle direkt über die SageMaker KI-Konsole.
**Topics**
+ [Verwenden von Basismodellen in Studio](jumpstart-foundation-models-use-studio-updated.md)
+ [Verwenden Sie Fundamentmodelle in Amazon SageMaker Studio Classic](jumpstart-foundation-models-use-studio.md)
+ [Verwenden Sie Foundation-Modelle mit dem SDK SageMaker Python](jumpstart-foundation-models-use-python-sdk.md)
+ [Entdecken Sie grundlegende Modelle in der SageMaker AI Console](jumpstart-foundation-models-use-console.md)
# Verwenden von Basismodellen in Studio
Amazon SageMaker Studio ermöglicht Ihnen die Feinabstimmung, Bereitstellung und Evaluierung sowohl öffentlich verfügbarer als auch proprietärer JumpStart Basismodelle direkt über die Studio-Benutzeroberfläche.
**Wichtig**
Seit dem 30. November 2023 heißt das vorherige Amazon SageMaker Studio-Erlebnis jetzt Amazon SageMaker Studio Classic. Der folgende Abschnitt bezieht sich auf die Verwendung der aktualisierten Studio-Erfahrung. Informationen zur Verwendung der Studio-Classic-Anwendung finden Sie unter [Amazon SageMaker Studio Klassisch](studio.md).
Um zu beginnen, navigieren Sie zur JumpStart Landing Page in Amazon SageMaker Studio. Sie können über die **Startseite** oder das Menü auf der linken Seite darauf zugreifen. Auf der **JumpStart**Landingpage können Sie Model-Hubs von Anbietern sowohl öffentlich verfügbarer als auch proprietärer Modelle erkunden und nach Modellen suchen.
In jedem Modell-Hub können Sie Modelle nach den Kategorien **Meiste Likes**, **Meiste Downloads** und **Zuletzt aktualisiert** sortieren oder sie nach Aufgabe filtern. Wählen Sie ein Modell aus, um die zugehörige Detailkarte anzuzeigen. Auf der Modelldetailkarte können Sie je nach verfügbarer Option wählen, ob Sie das Modell **optimieren**, **bereitstellen** oder **bewerten** möchten. Beachten Sie, dass nicht alle Modelle für die Optimierung oder Bewertung verfügbar sind.
Weitere Informationen zu den ersten Schritten mit Amazon SageMaker Studio finden Sie unter[Amazon SageMaker Studio](studio-updated.md).
**Topics**
+ [Optimieren eines Modells in Studio](jumpstart-foundation-models-use-studio-updated-fine-tune.md)
+ [Bereitstellen eines Modells in Studio](jumpstart-foundation-models-use-studio-updated-deploy.md)
+ [Bewerten eines Modells in Studio](jumpstart-foundation-models-use-studio-updated-evaluate.md)
+ [Verwenden Sie Ihre SageMaker JumpStart Modelle in Amazon Bedrock](jumpstart-foundation-models-use-studio-updated-register-bedrock.md)
# Optimieren eines Modells in Studio
Durch die Optimierung wird ein vortrainiertes Modell anhand eines neuen Datensatzes trainiert, ohne dass ein Training von Grund auf erforderlich ist. Dieser Prozess, der auch als Transferlernen bezeichnet wird, kann genaue Modelle mit kleineren Datensätzen und weniger Trainingszeit erzeugen. Um JumpStart Fundamentmodelle zu optimieren, navigieren Sie zu einer Modelldetailkarte in der Studio-Benutzeroberfläche. Weitere Informationen zum Öffnen JumpStart in Studio finden Sie unter[In Studio öffnen JumpStart](studio-jumpstart.md#jumpstart-open-studio). Nachdem Sie zur Modelldetailkarte Ihrer Wahl navigiert haben, wählen Sie in der oberen rechten Ecke **Trainieren** aus. Beachten Sie, dass nicht für alle Modelle eine Optimierung verfügbar ist.
**Wichtig**
Einige Basismodelle erfordern vor der Optimierung die ausdrückliche Annahme einer Endbenutzer-Lizenzvereinbarung (EULA). Weitere Informationen finden Sie unter [EULA-Akzeptanz in Amazon Studio SageMaker](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula-studio).
## Modelleinstellungen
Wenn Sie ein vortrainiertes JumpStart Foundation-Modell in Amazon SageMaker Studio verwenden, wird der **Speicherort des Modellartefakts (Amazon S3 S3-URI)** standardmäßig aufgefüllt. Um die standardmäßige Amazon-S3-URI zu bearbeiten, wählen Sie **Speicherort des Modellartefakts eingeben** aus. Nicht alle Modelle unterstützen das Ändern des Speicherorts für Modellartefakte.
## Dateneinstellungen
Geben Sie im Feld **Daten** einen Amazon-S3-URI ein, der auf den Speicherort Ihres Trainingsdatensatzes verweist. Der standardmäßige Amazon-S3-URI verweist auf einen Beispiel-Trainingsdatensatz. Um den standardmäßige Amazon-S3-URI zu bearbeiten, wählen Sie **Trainingsdatensatz eingeben** aus und ändern Sie den URI. Informationen zur Formatierung von Trainingsdaten finden Sie auf der Modelldetailkarte in Amazon SageMaker Studio.
## Hyperparameter
Sie können die Hyperparameter des Trainingsauftrags anpassen, die zur Feinabstimmung des Modells verwendet werden. Die Hyperparameter, die für jedes optimierbare Modell verfügbar sind, unterscheiden sich je nach Modell.
Die folgenden Hyperparameter sind in Modellen üblich:
+ **Epochen** – Eine Epoche ist ein Zyklus durch den gesamten Datensatz. Mehrere Intervalle formen einen Batch und mehrere Batches formen eine Epoche. Es werden mehrere Epochen durchgeführt, bis die Genauigkeit des Modells ein akzeptables Niveau erreicht hat oder wenn die Fehlerquote unter ein akzeptables Niveau fällt.
+ **Lernrate** – Der Umfang, um den Werte zwischen den Epochen geändert werden sollten. Während der Optimierung des Modells werden seine internen Gewichtungen angepasst und die Fehlerquoten überprüft, um festzustellen, ob sich das Modell verbessert. Eine typische Lernrate liegt bei 0,1 oder 0,01, wobei 0,01 eine viel geringere Anpassung darstellt und dazu führen kann, dass das Training lange dauert, bis das Training konvergiert, wohingegen 0,1 viel größer ist und zu einem Überschwingen des Trainings führen kann. Dies ist einer der wichtigsten Hyperparameter, die Sie für das Training Ihres Modells anpassen können. Beachten Sie, dass bei Textmodellen eine viel geringere Lernrate (5e-5 für BERT) zu einem genaueren Modell führen kann.
+ **Batchgröße** — Die Anzahl der Datensätze aus dem Datensatz, die für jedes Intervall ausgewählt werden sollen, das GPUs zum Training an den gesendet werden soll.
Lesen Sie die QuickInfo-Prompts und zusätzlichen Informationen auf der Modelldetailkarte auf der Studio-Benutzeroberfläche, um mehr über Hyperparameter zu erfahren, die für das Modell Ihrer Wahl spezifisch sind.
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).
## Bereitstellung
Geben Sie den Typ der Trainingsinstanz und den Speicherort des Ausgabeartefakts für Ihren Trainingsjob an. Im Rahmen der Optimierung der Studio-Benutzeroberfläche können Sie nur aus Instances wählen, die mit dem Modell Ihrer Wahl kompatibel sind. Der standardmäßige Speicherort für Ausgabeartefakte ist der SageMaker AI-Standard-Bucket. Um den Speicherort des Ausgabeartefakts zu ändern, wählen Sie **Standort des Ausgabeartefakts eingeben** und ändern Sie den Amazon-S3-URI.
## Sicherheit
Geben Sie die Sicherheitseinstellungen an, die für Ihren Schulungsjob verwendet werden sollen, einschließlich der IAM-Rolle, die SageMaker KI zum Trainieren Ihres Modells verwendet, ob Ihr Schulungsjob eine Verbindung zu einer Virtual Private Cloud (VPC) herstellen soll, und aller Verschlüsselungsschlüssel zum Schutz Ihrer Daten.
## Zusätzliche Informationen
Im Feld **Zusätzliche Informationen** können Sie den Namen des Trainingsjobs bearbeiten. Sie können auch Tags in Form von Schlüssel-Wert-Paaren hinzufügen und entfernen, um Ihre Optimierungs-Trainingsjobs zu organisieren und zu kategorisieren.
Nachdem Sie die Informationen für Ihre Optimierungskonfiguration eingegeben haben, wählen Sie **Absenden** aus. Wenn das vortrainierte Basismodell, das Sie für die Optimierung ausgewählt haben, vor dem Training die ausdrückliche Zustimmung zu einer Endbenutzer-Lizenzvereinbarung (EULA) erfordert, wird die EULA in einem Popup-Fenster angezeigt. Um die Bedingungen der EULA zu akzeptieren, wählen Sie **Akzeptieren** aus. Sie sind dafür verantwortlich, alle geltenden Lizenzbedingungen zu überprüfen und einzuhalten sowie sicherzustellen, dass sie für Ihren Anwendungsfall akzeptabel sind, bevor Sie ein Model herunterladen oder verwenden.
# Bereitstellen eines Modells in Studio
Um JumpStart Foundation-Modelle bereitzustellen, navigieren Sie in der Studio-Benutzeroberfläche zu einer Modelldetailkarte. Weitere Informationen zum Öffnen JumpStart in Studio finden Sie unter[In Studio öffnen JumpStart](studio-jumpstart.md#jumpstart-open-studio). Nachdem Sie zur Modelldetailseite Ihrer Wahl navigiert haben, wählen Sie in der oberen rechten Ecke der Studio-Benutzeroberfläche die Option **Bereitstellen** aus. Folgen Sie anschließend den Schritten unter [Bereitstellen von Modellen mit SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints-deploy-models.html#deploy-models-studio).
**Wichtig**
Einige Basismodelle erfordern vor der Bereitstellung die ausdrückliche Annahme einer Endbenutzer-Lizenzvereinbarung (EULA). Weitere Informationen finden Sie unter [EULA-Akzeptanz in Amazon Studio SageMaker](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula-studio).
# Bewerten eines Modells in Studio
Amazon SageMaker JumpStart bietet Integrationen mit SageMaker Clarify Foundation Model Evaluations (FME) in Studio. Wenn für ein JumpStart Modell integrierte Evaluierungsfunktionen verfügbar sind, können Sie in der JumpStart Studio-Benutzeroberfläche in der oberen rechten Ecke der Modelldetailseite die Option **Evaluieren** auswählen. Weitere Informationen finden Sie unter [Bewerten eines Basismodells](https://docs.aws.amazon.com/sagemaker/latest/dg/jumpstart-foundation-models-evaluate.html).
# Verwenden Sie Ihre SageMaker JumpStart Modelle in Amazon Bedrock
Sie können die Modelle registrieren, die Sie von Amazon SageMaker JumpStart auf Amazon Bedrock bereitgestellt haben. Mit Amazon Bedrock können Sie Ihr Modell hinter mehreren Endpunkten hosten. Sie können auch Features von Amazon Bedrock wie Agenten und Wissensdatenbanken verwenden. Weitere Informationen zur Verwendung von Amazon-Bedrock-Modellen finden Sie unter [https://docs.aws.amazon.com/bedrock/latest/userguide/amazon-bedrock-marketplace.html](https://docs.aws.amazon.com/bedrock/latest/userguide/amazon-bedrock-marketplace.html).
**Wichtig**
Um Ihre Modelle zu Amazon Bedrock zu migrieren, empfehlen wir, Ihrer IAM-Rolle eine [AmazonBedrockFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonBedrockFullAccess.html)Richtlinie beizufügen. Wenn Sie die verwaltete Richtlinie nicht anfügen können, stellen Sie sicher, dass Ihre IAM-Rolle über folgende Berechtigungen verfügt:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "BedrockAll",
"Effect": "Allow",
"Action": [
"bedrock:*"
],
"Resource": "*"
},
{
"Sid": "DescribeKey",
"Effect": "Allow",
"Action": [
"kms:DescribeKey"
],
"Resource": "arn:*:kms:*:::*"
},
{
"Sid": "APIsWithAllResourceAccess",
"Effect": "Allow",
"Action": [
"iam:ListRoles",
"ec2:DescribeVpcs",
"ec2:DescribeSubnets",
"ec2:DescribeSecurityGroups"
],
"Resource": "*"
},
{
"Sid": "MarketplaceModelEndpointMutatingAPIs",
"Effect": "Allow",
"Action": [
"sagemaker:CreateEndpoint",
"sagemaker:CreateEndpointConfig",
"sagemaker:CreateModel",
"sagemaker:CreateInferenceComponent",
"sagemaker:DeleteInferenceComponent",
"sagemaker:DeleteEndpoint",
"sagemaker:UpdateEndpoint"
],
"Resource": [
"arn:aws:sagemaker:*:*:endpoint/*",
"arn:aws:sagemaker:*:*:endpoint-config/*",
"arn:aws:sagemaker:*:*:model/*"
],
"Condition": {
"StringEquals": {
"aws:CalledViaLast": "bedrock.amazonaws.com"
}
}
},
{
"Sid": "BedrockEndpointTaggingOperations",
"Effect": "Allow",
"Action": [
"sagemaker:AddTags",
"sagemaker:DeleteTags"
],
"Resource": [
"arn:aws:sagemaker:*:*:endpoint/*",
"arn:aws:sagemaker:*:*:endpoint-config/*",
"arn:aws:sagemaker:*:*:model/*"
]
},
{
"Sid": "MarketplaceModelEndpointNonMutatingAPIs",
"Effect": "Allow",
"Action": [
"sagemaker:DescribeEndpoint",
"sagemaker:DescribeEndpointConfig",
"sagemaker:DescribeModel",
"sagemaker:DescribeInferenceComponent",
"sagemaker:ListEndpoints",
"sagemaker:ListTags"
],
"Resource": [
"arn:aws:sagemaker:*:*:endpoint/*",
"arn:aws:sagemaker:*:*:endpoint-config/*",
"arn:aws:sagemaker:*:*:model/*"
],
"Condition": {
"StringEquals": {
"aws:CalledViaLast": "bedrock.amazonaws.com"
}
}
},
{
"Sid": "BedrockEndpointInvokingOperations",
"Effect": "Allow",
"Action": [
"sagemaker:InvokeEndpoint",
"sagemaker:InvokeEndpointWithResponseStream"
],
"Resource": [
"arn:aws:sagemaker:*:*:endpoint/*"
],
"Condition": {
"StringEquals": {
"aws:CalledViaLast": "bedrock.amazonaws.com"
}
}
},
{
"Sid": "DiscoveringMarketplaceModel",
"Effect": "Allow",
"Action": [
"sagemaker:DescribeHubContent"
],
"Resource": [
"arn:aws:sagemaker:*:aws:hub-content/SageMakerPublicHub/Model/*",
"arn:aws:sagemaker:*:aws:hub/SageMakerPublicHub"
]
},
{
"Sid": "AllowMarketplaceModelsListing",
"Effect": "Allow",
"Action": [
"sagemaker:ListHubContents"
],
"Resource": "arn:aws:sagemaker:*:aws:hub/SageMakerPublicHub"
},
{
"Sid": "RetrieveSubscribedMarketplaceLicenses",
"Effect": "Allow",
"Action": [
"license-manager:ListReceivedLicenses"
],
"Resource": [
"*"
]
},
{
"Sid": "PassRoleToSageMaker",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::*:role/*Sagemaker*ForBedrock*"
],
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"sagemaker.amazonaws.com",
"bedrock.amazonaws.com"
]
}
}
},
{
"Sid": "PassRoleToBedrock",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": "arn:aws:iam::*:role/*AmazonBedrock*",
"Condition": {
"StringEquals": {
"iam:PassedToService": [
"bedrock.amazonaws.com"
]
}
}
}
]
}
```
Die Richtlinie „Amazon Bedrock Full Access“ gewährt nur Berechtigungen für die Amazon Bedrock API. Um Amazon Bedrock in der verwenden zu können AWS-Managementkonsole, muss Ihre IAM-Rolle außerdem über die folgenden Berechtigungen verfügen:
```
{
"Sid": "AllowConsoleS3AccessForBedrockMarketplace",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:GetBucketCORS",
"s3:ListBucket",
"s3:ListBucketVersions",
"s3:GetBucketLocation"
],
"Resource": "*"
}
```
Wenn Sie Ihre eigene Richtlinie erstellen, müssen Sie die Richtlinienerklärung beifügen, die Aktionen in Amazon Bedrock Marketplace für die Ressource ermöglicht. Die folgende Richtlinie ermöglicht es Amazon Bedrock beispielsweise, den `InvokeModel`-Vorgang für ein Modell zu verwenden, das Sie auf einem Endpunkt bereitgestellt haben.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "BedrockAll",
"Effect": "Allow",
"Action": [
"bedrock:InvokeModel"
],
"Resource": [
"arn:aws:bedrock:us-east-1:111122223333:marketplace/model-endpoint/all-access"
]
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": ["sagemaker:InvokeEndpoint"],
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:endpoint/*",
"Condition": {
"StringEquals": {
"aws:ResourceTag/project": "example-project-id",
"aws:CalledViaLast": "bedrock.amazonaws.com"
}
}
}
]
}
```
Nachdem Sie ein Modell bereitgestellt haben, können Sie es möglicherweise in Amazon Bedrock verwenden. Um zu sehen, ob Sie es in Amazon Bedrock verwenden können, navigieren Sie zur Modelldetailkarte auf der Studio-Benutzeroberfläche. Wenn auf der Modellkarte steht, dass es **für Bedrock bereit** ist, können Sie das Modell bei Amazon Bedrock registrieren.
**Wichtig**
Standardmäßig SageMaker JumpStart deaktiviert Amazon den Netzwerkzugriff für die Modelle, die Sie bereitstellen. Wenn Sie den Netzwerkzugriff aktiviert haben, können Sie das Modell nicht mit Amazon Bedrock verwenden. Wenn Sie das Modell mit Amazon Bedrock verwenden möchten, müssen Sie es mit deaktiviertem Netzwerkzugriff erneut bereitstellen.
Um es mit Amazon Bedrock zu verwenden, navigieren Sie zur Seite mit den **Endpunktdetails** und wählen Sie in der oberen rechten Ecke der Studio-Benutzeroberfläche die Option **Mit Bedrock verwenden** aus. Nachdem das Pop-up angezeigt wurde, wählen Sie **Für Bedrock registrieren** aus.
# Verwenden Sie Fundamentmodelle in Amazon SageMaker Studio Classic
Über die Benutzeroberfläche von Studio Classic können Sie sowohl öffentlich verfügbare als auch proprietäre JumpStart Foundation-Modelle optimieren und bereitstellen.
**Wichtig**
Seit dem 30. November 2023 heißt das vorherige Amazon SageMaker Studio-Erlebnis jetzt Amazon SageMaker Studio Classic. Der folgende Abschnitt bezieht sich konkret auf die Verwendung der Studio-Classic-Anwendung. Informationen zur Verwendung der aktualisierten Studio-Konfiguration finden Sie unter [Amazon SageMaker Studio](studio-updated.md).
Studio Classic wird weiterhin für bestehende Workloads beibehalten, ist aber nicht mehr für das Onboarding verfügbar. Sie können nur bestehende Studio Classic-Anwendungen beenden oder löschen und keine neuen erstellen. Wir empfehlen Ihnen, [Ihren Workload auf das neue Studio-Erlebnis zu migrieren](studio-updated-migrate.md).
Informationen zu den ersten Schritten mit Studio Classic finden Sie unter [Starten Sie Amazon SageMaker Studio Classic](studio-launch.md).
![\[JumpStart foundation models available in Amazon SageMaker Studio Classic.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/jumpstart/jumpstart-fm-studio.png)
Wählen Sie nach dem Öffnen von Amazon SageMaker Studio Classic im SageMaker JumpStart Abschnitt des Navigationsbereichs **Modelle, Notizbücher, Lösungen** aus. Scrollen Sie dann nach unten, um je nach Anwendungsfall entweder den Abschnitt **Grundlagenmodelle: Textgenerierung** oder **Grundlagenmodelle: Bildgenerierung** zu finden.
Sie können auf einer vorgeschlagenen Grundlagenmodellkarte die Option **Modell anzeigen** oder **Alle Modelle untersuchen** wählen, um alle verfügbaren Grundlagenmodelle für die Text- oder Bildgenerierung anzuzeigen. Wenn Sie alle verfügbaren Modelle anzeigen möchten, können Sie die verfügbaren Modelle weiter nach Aufgabe, Datentyp, Inhaltstyp oder Framework filtern. Sie können auch direkt in der **Suchleiste** nach einem Modellnamen suchen. Wenn Sie Hilfe bei der Auswahl eines Modells benötigen, finden Sie weitere Informationen 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 [EULA-Akzeptanz in Amazon Studio SageMaker](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula-studio).
Nachdem Sie in Studio Classic **Modell anzeigen** für das Basismodell Ihrer Wahl ausgewählt haben, können Sie das Modell bereitstellen. Weitere Informationen finden Sie unter [Bereitstellen eines Modells](jumpstart-deploy.md).
Sie können auch **Notebook öffnen** im Abschnitt **In Notebook ausführen** wählen, um ein Beispiel-Notebook für das Basismodell direkt in Studio Classic auszuführen.
**Anmerkung**
Um ein proprietäres Basismodell in Studio Classic bereitstellen zu können, müssen Sie das Modell zunächst unter AWS Marketplace abonnieren. Der AWS Marketplace Link befindet sich im zugehörigen Beispielnotizbuch in Studio Classic.
Wenn das Modell optimierbar ist, können Sie auch eine Feinabstimmung des Modells vornehmen. Weitere Informationen finden Sie unter [Feinabstimmung eines Modells](jumpstart-fine-tune.md). Eine Liste der JumpStart Fundamentmodelle, für die eine Feinabstimmung möglich ist, finden Sie unter. [Basismodelle und Hyperparameter für die Optimierung](jumpstart-foundation-models-fine-tuning.md)
# Verwenden Sie Foundation-Modelle mit dem SDK SageMaker Python
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
**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
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
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
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
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
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
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
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
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
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).
# Entdecken Sie grundlegende Modelle in der SageMaker AI Console
Sie können JumpStart Fundamentmodelle direkt über die Amazon SageMaker AI Console erkunden.
1. Öffnen Sie die Amazon SageMaker AI-Konsole unter [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Suchen Sie **JumpStart**im linken Navigationsbereich und wählen Sie **Foundation-Modelle**.
1. Durchsuchen Sie Modelle oder suchen Sie nach einem bestimmten Modell. Hinweise zur Modellauswahl finden Sie unter [Verfügbare Basismodelle](jumpstart-foundation-models-latest.md). Wählen Sie **Modell anzeigen**, um die Modelldetailseite für das Grundlagenmodell Ihrer Wahl aufzurufen.
1. Wenn es sich bei dem Modell um ein proprietäres Modell handelt, wählen Sie in der oberen rechten Ecke der Modelldetailseite die Option **Abonnieren** aus, um das Modell in AWS Marketplace zu abonnieren. Sie sollten eine E-Mail erhalten, in der Ihr Abonnement für das Modell Ihrer Wahl bestätigt wird. 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). Für öffentlich verfügbare Grundlagenmodelle ist kein Abonnement erforderlich.
1. Um ein Beispiel-Notizbuch in **anzusehen GitHub, wählen Sie in der oberen rechten Ecke der Modelldetailseite die Option Code anzeigen** aus.
1. Um ein Beispiel-Notizbuch direkt in Amazon SageMaker Studio Classic anzuzeigen und auszuführen, wählen Sie **in der oberen rechten Ecke der Modelldetailseite die Option Notizbuch in Studio öffnen**.
# Modellquellen und Lizenzvereinbarungen
Amazon SageMaker JumpStart bietet Zugriff auf Hunderte von öffentlich verfügbaren und proprietären Stiftungsmodellen von Drittanbietern und Partnern. Sie können die Auswahl des JumpStart Fundamentmodells direkt in der SageMaker AI-Konsole, Studio oder Studio Classic erkunden.
## Lizenzen und Modellquellen
Amazon SageMaker JumpStart bietet Zugriff sowohl auf öffentlich verfügbare als auch auf proprietäre Stiftungsmodelle. Grundlagenmodelle werden von externen Open-Source-Anbietern und proprietären Anbietern integriert und verwaltet. Daher werden sie unter verschiedenen Lizenzen veröffentlicht, die von der Modellquelle angegeben wurden. Achten Sie darauf, die Lizenz für jedes von Ihnen verwendete Grundlagenmodell zu überprüfen. Sie sind dafür verantwortlich, alle geltenden Lizenzbedingungen zu überprüfen und einzuhalten sowie sicherzustellen, dass sie für Ihren Anwendungsfall akzeptabel sind, bevor Sie den Inhalt herunterladen oder verwenden. Einige Beispiele für gängige Grundlagenmodell-Lizenzen:
+ Alexa Teacher Model
+ Apache 2.0
+ BigScience Lizenz für verantwortungsvolle KI v1.0
+ CreativeML Open RAIL\$1\$1-M-Lizenz
Achten Sie auch bei allen proprietären Grundlagenmodellen darauf, die Nutzungsbedingungen und Nutzungsrichtlinien des Modellanbieters zu überprüfen und einzuhalten. Wenn Sie Fragen zu den Lizenzinformationen für ein bestimmtes proprietäres Modell haben, wenden Sie sich direkt an den Modellanbieter. Die Kontaktinformationen des Modellanbieters finden Sie auf der Registerkarte **Support** auf jeder Modellseite in AWS Marketplace.
## Endbenutzer-Lizenzvereinbarungen
Einige JumpStart Foundation-Modelle erfordern vor der Verwendung die ausdrückliche Annahme einer Endbenutzer-Lizenzvereinbarung (EULA).
### EULA-Akzeptanz in Amazon Studio SageMaker
Möglicherweise werden Sie aufgefordert, eine Endbenutzer-Lizenzvereinbarung zu akzeptieren, bevor Sie ein Basismodell in Studio optimieren, bereitstellen oder evaluieren JumpStart können. Informationen zu den ersten Schritten mit JumpStart Foundation-Modellen in Studio finden Sie unter. [Verwenden von Basismodellen in Studio](jumpstart-foundation-models-use-studio-updated.md)
**Wichtig**
Seit dem 30. November 2023 heißt das vorherige Amazon SageMaker Studio-Erlebnis jetzt Amazon SageMaker Studio Classic. Der folgende Abschnitt bezieht sich auf die Verwendung der aktualisierten Studio-Erfahrung. Informationen zur Verwendung der Studio-Classic-Anwendung finden Sie unter [Amazon SageMaker Studio Klassisch](studio.md).
Einige JumpStart Basismodelle erfordern vor der Bereitstellung die Annahme einer Endbenutzer-Lizenzvereinbarung. Wenn dies auf das Basismodell zutrifft, das Sie verwenden möchten, zeigt Studio ein Fenster an, das den Inhalt der Endbenutzer-Lizenzvereinbarung enthält. Sie sind dafür verantwortlich, alle geltenden Lizenzbedingungen zu überprüfen und einzuhalten sowie sicherzustellen, dass sie für Ihren Anwendungsfall akzeptabel sind, bevor Sie ein Model herunterladen oder verwenden.
#### EULA-Akzeptanz in Amazon SageMaker Studio Classic
Möglicherweise werden Sie aufgefordert, eine Endbenutzer-Lizenzvereinbarung zu akzeptieren, bevor Sie ein JumpStart Foundation-Modell bereitstellen oder ein JumpStart Foundation-Model-Notizbuch in Studio Classic öffnen. Informationen zu den ersten Schritten mit JumpStart Foundation-Modellen in Studio Classic finden Sie unter[Verwenden Sie Fundamentmodelle in Amazon SageMaker Studio Classic](jumpstart-foundation-models-use-studio.md).
**Wichtig**
Seit dem 30. November 2023 heißt das vorherige Amazon SageMaker Studio-Erlebnis jetzt Amazon SageMaker Studio Classic. Der folgende Abschnitt bezieht sich konkret auf die Verwendung der Studio-Classic-Anwendung. Informationen zur Verwendung der aktualisierten Studio-Konfiguration finden Sie unter [Amazon SageMaker Studio](studio-updated.md).
Studio Classic wird weiterhin für bestehende Workloads beibehalten, ist aber nicht mehr für das Onboarding verfügbar. Sie können nur bestehende Studio Classic-Anwendungen beenden oder löschen und keine neuen erstellen. Wir empfehlen Ihnen, [Ihren Workload auf das neue Studio-Erlebnis zu migrieren](studio-updated-migrate.md).
Bei einigen JumpStart Basismodellen ist vor der Bereitstellung die Annahme einer Endbenutzer-Lizenzvereinbarung erforderlich. Wenn dies auf das Basismodell zutrifft, das Sie verwenden möchten, werden Sie von Studio Classic in einem Fenster mit dem Titel **Endbenutzer-Lizenzvereinbarung (EULA) und Acceptable Use Policy (AUP) unten prüfen** dazu aufgefordert, nachdem Sie entweder **Bereitstellen** oder **Notebook öffnen** ausgewählt haben. Sie sind dafür verantwortlich, alle geltenden Lizenzbedingungen zu überprüfen und einzuhalten sowie sicherzustellen, dass sie für Ihren Anwendungsfall akzeptabel sind, bevor Sie ein Model herunterladen oder verwenden.
### Annahme der EULA mit dem SDK SageMaker Python
In den folgenden Abschnitten erfahren Sie, wie Sie bei der Bereitstellung oder Feinabstimmung eines JumpStart Modells mit dem SDK explizit die EULA-Akzeptanz deklarieren. SageMaker Python Weitere Informationen zu den ersten Schritten mit JumpStart Foundation-Modellen mithilfe des SageMaker Python SDK finden Sie unter. [Verwenden Sie Foundation-Modelle mit dem SDK SageMaker Python](jumpstart-foundation-models-use-python-sdk.md)
Führen Sie Folgendes aus, bevor Sie beginnen:
+ Aktualisieren Sie auf die neueste Version des verwendeten Modells.
+ Installieren Sie die neueste Version des SageMaker Python SDK.
**Wichtig**
Um den folgenden Workflow verwenden zu können, muss Version [2.198.0](https://github.com/aws/sagemaker-python-sdk/releases/tag/v2.198.0) oder höher des SageMaker Python SDK installiert sein.
#### EULA-Akzeptanz bei der Bereitstellung eines Modells JumpStart
Bei Modellen, die die Annahme einer Endbenutzer-Lizenzvereinbarung erfordern, müssen Sie bei der Bereitstellung Ihres Modells ausdrücklich die Zustimmung zur EULA erklären. JumpStart
```
from sagemaker.jumpstart.model import JumpStartModel
model_id = "meta-textgeneration-llama-2-13b"
my_model = JumpStartModel(model_id=model_id)
# Declare EULA acceptance when deploying your JumpStart model
predictor = my_model.deploy(accept_eula=True)
```
Der `accept_eula`-Wert ist standardmäßig `None` und muss explizit als `True` neu definiert werden, um die Endbenutzer-Lizenzvereinbarung anzunehmen. Weitere Informationen finden Sie unter [JumpStartModel](https://sagemaker.readthedocs.io/en/stable/api/inference/model.html#sagemaker.jumpstart.model.JumpStartModel).
#### Annahme der EULA bei der Feinabstimmung eines Modells JumpStart
Bei der Feinabstimmung von Modellen, die die Annahme einer Endbenutzer-Lizenzvereinbarung erfordern, müssen Sie bei der Ausführung der Methode für Ihren Kalkulator ausdrücklich die `fit()` Zustimmung zur Endbenutzer-Lizenzvereinbarung erklären. JumpStart Nach der Optimierung eines vortrainierten Modells werden die Gewichtungen des ursprünglichen Modells geändert. Wenn Sie das optimierte Modell später bereitstellen, müssen Sie daher keine EULA akzeptieren.
**Anmerkung**
Im folgenden Beispiel wird `accept_eula=False` festgelegt. Sie sollten den Wert manuell auf `True` ändern, um die EULA zu akzeptieren.
```
from sagemaker.jumpstart.estimator import JumpStartEstimator
model_id = "meta-textgeneration-llama-2-13b"
# Declare EULA acceptance when defining your JumpStart estimator
estimator = JumpStartEstimator(model_id=model_id)
estimator.fit(accept_eula=False,
{"train": training_dataset_s3_path, "validation": validation_dataset_s3_path}
)
```
Der `accept_eula`-Wert ist standardmäßig `None` und muss innerhalb der `fit()`-Methode explizit als `"true"` neu definiert werden, um die Endbenutzer-Lizenzvereinbarung anzunehmen. Weitere Informationen finden Sie unter [JumpStartEstimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.jumpstart.estimator.JumpStartEstimator).
#### Versionen des EULA Acceptance SageMaker Python SDK vor 2.198.0
**Wichtig**
Wenn Sie Versionen des SageMaker Python SDK vor [2.198.0](https://github.com/aws/sagemaker-python-sdk/releases/tag/v2.198.0) verwenden, müssen Sie die SageMaker `Predictor` Klasse verwenden, um eine Modell-EULA zu akzeptieren.
Nachdem Sie ein JumpStart Foundation-Modell mithilfe des SageMaker Python SDK programmgesteuert bereitgestellt haben, können Sie mit der Klasse Inferenz für Ihren bereitgestellten Endpunkt ausführen. SageMaker `[Predictor](https://sagemaker.readthedocs.io/en/stable/api/inference/predictors.html)` Bei Modellen, die die Annahme einer Endbenutzer-Lizenzvereinbarung erfordern, müssen Sie in Ihrem Aufruf zur `Predictor`-Klasse ausdrücklich die Annahme der EULA erklären:
```
predictor.predict(payload, custom_attributes="accept_eula=true")
```
Der `accept_eula`-Wert ist standardmäßig `false` und muss explizit als `true` neu definiert werden, um die Endbenutzer-Lizenzvereinbarung anzunehmen. Der Predictor gibt einen Fehler zurück, wenn Sie versuchen, eine Inferenz auszuführen, wenn `accept_eula` auf `false` gesetzt ist. Weitere Informationen zu den ersten Schritten mit JumpStart Foundation-Modellen mithilfe des SageMaker Python SDK finden Sie unter. [Verwenden Sie Foundation-Modelle mit dem SDK SageMaker Python](jumpstart-foundation-models-use-python-sdk.md)
**Wichtig**
Der Parameter `custom_attributes` akzeptiert Schlüssel-Wert-Paare im Format `"key1=value1;key2=value2"`. Wenn Sie denselben Schlüssel mehrmals verwenden, verwendet der Inferenzserver den letzten Wert, der dem Schlüssel zugeordnet ist. Wenn Sie beispielsweise `"accept_eula=false;accept_eula=true"` an den Parameter `custom_attributes` übergeben, ordnet der Inferenzserver den Wert `true` dem Schlüssel `accept_eula` zu.
# Anpassung des Basismodells
Grundlagenmodelle sind extrem leistungsstarke Modelle, mit denen sich eine Vielzahl von Aufgaben lösen lässt. Um die meisten Aufgaben effektiv lösen zu können, müssen diese Modelle in irgendeiner Form angepasst werden.
Die empfohlene Methode, ein Grundlagenmodell zunächst an einen bestimmten Anwendungsfall anzupassen, ist mittels Prompt-Engineering. Wenn Sie Ihr Grundlagenmodell mit ausgereiften, kontextreichen Eingabeaufforderungen ausstatten, können Sie ohne Feinabstimmung oder Änderung der Modellgewichtungen die gewünschten Ergebnisse erzielen. Weitere Informationen finden Sie unter [Prompt-Engineering für Grundlagenmodelle](jumpstart-foundation-models-customize-prompt-engineering.md).
Wenn Prompt-Engineering allein nicht ausreicht, um Ihr Grundlagenmodell an eine bestimmte Aufgabe anzupassen, können Sie ein Grundlagenmodell anhand zusätzlicher domainspezifischer Daten optimieren. Weitere Informationen finden Sie unter [Basismodelle und Hyperparameter für die Optimierung](jumpstart-foundation-models-fine-tuning.md). Der Feinabstimmungsprozess beinhaltet die Änderung der Modellgewichtungen.
Wenn Sie Ihr Modell ohne Neutraining mit Informationen aus einer Wissensbibliothek anpassen möchten, finden Sie weitere Informationen unter [Retrieval Augmented Generation](jumpstart-foundation-models-customize-rag.md).
# Prompt-Engineering für Grundlagenmodelle
Prompt-Engineering ist der Prozess, bei dem die Eingabeaufforderungen oder Eingabestimuli für ein Sprachmodell entworfen und optimiert werden, um bestimmte Ausgabetypen zu generieren. Prompt-Engineering beinhaltet die Auswahl geeigneter Schlüsselwörter, die Bereitstellung von Kontext und die Gestaltung der Eingaben auf eine Weise, dass das Modell die gewünschte Reaktion hervorruft. Dies ist eine wichtige Technik, um das Verhalten und die Ausgabe von Grundlagenmodellen aktiv mitzugestalten.
Effektives Prompt-Engineering ist für die Steuerung des Modellverhaltens und die Erzielung der gewünschten Reaktionen entscheidend. Durch Prompt-Engineering können Sie den Ton, den Stil und das Fachwissen eines Modells steuern, ohne aufwändigere Anpassungen wie Feinabstimmungen vornehmen zu müssen. Wir empfehlen, für das Prompt-Engineering Zeit einzuplanen, bevor Sie eine Feinabstimmung eines Modells anhand zusätzlicher Daten erwägen. Ziel ist es, dem Modell ausreichend Kontext und Leitlinien zur Verfügung zu stellen, damit es in Szenarien mit ungesehenen oder begrenztem Datenvolumen verallgemeinern und eine gute Leistung erbringen kann.
## Zero-Shot-Lernen
Beim Zero-Shot-Lernen wird ein Modell so trainiert, dass es verallgemeinern und für bisher ungesehene Klassen oder Aufgaben Vorhersagen treffen kann. Für das Prompt-Engineering in Zero-Shot-Lernumgebungen empfehlen wir, Eingabeaufforderungen zu erstellen, die explizit Informationen über die Zielaufgabe und das gewünschte Ausgabeformat enthalten. Wenn Sie beispielsweise ein Grundlagenmodell für die Zero-Shot-Textklassifizierung für eine Gruppe von Klassen verwenden möchten, die das Modell während des Trainings nicht gesehen hat, könnte eine gut durchdachte Aufforderung folgendermaßen lauten: `"Classify the following text as either sports, politics, or entertainment: [input text]."` Indem Sie die Zielklassen und das erwartete Ausgabeformat explizit angeben, können Sie das Modell dazu bringen, auch für ungesehene Klassen genaue Vorhersagen zu treffen.
## Few-Shot-Lernen
Beim Few-Shot Learning wird ein Modell mit einer begrenzten Datenmenge für neue Klassen oder Aufgaben trainiert. In Few-Shot-Lernumgebungen konzentriert sich Prompt-Engineering auf die Gestaltung von Aufforderungen, die die begrenzten verfügbaren Trainingsdaten effektiv nutzen. Wenn Sie beispielsweise ein Grundlagenmodell für eine Aufgabe zur Bildklassifizierung verwenden und nur wenige Beispiele für eine neue Bildklasse haben, können Sie eine Eingabeaufforderung erstellen, die die verfügbaren gekennzeichneten Beispiele mit einem Platzhalter für die Zielklasse enthält. Die Aufforderung könnte beispielsweise folgendermaßen lauten: `"[image 1], [image 2], and [image 3] are examples of [target class]. Classify the following image as [target class]"`. Indem Sie die begrenzten gekennzeichneten Beispiele einbeziehen und die Zielklasse explizit angeben, können Sie das Modell dazu bringen, selbst mit minimalen Trainingsdaten zu verallgemeinern und genaue Vorhersagen zu treffen.
## Unterstützte Inferenzparameter
Eine Änderung der Inferenzparameter kann sich auch auf die Antworten auf Ihre Prompts auswirken. Sie können versuchen, Ihren Prompts so viel Spezifität und Kontext wie möglich hinzuzufügen, oder aber mit unterstützten Inferenzparametern experimentieren. Im Folgenden finden Sie Beispiele für einige häufig unterstützte Inferenzparameter:
| Inferenzparameter | Description |
| --- | --- |
| `max_new_tokens` | Die maximale Ausgabelänge einer Antwort des Basismodells. Gültige Werte: Ganzzahl, Bereich: Positive Ganzzahl. |
| `temperature` | Steuert die Zufälligkeit der Ausgabe. Eine höhere Temperatur führt zu einer Ausgabesequenz mit Wörtern mit niedriger Wahrscheinlichkeit und eine niedrigere Temperatur führt zu einer Ausgabesequenz mit Wörtern mit hoher Wahrscheinlichkeit. Wenn `temperature=0`, besteht die Antwort nur aus Wörtern mit der höchsten Wahrscheinlichkeit (Greedy-Dekodierung). Gültige Werte: Float, Bereich: Positiver Float. |
| `top_p` | In jedem Schritt der Textgenerierung nimmt das Modell Stichproben aus der kleinstmöglichen Wortgruppe mit einer kumulativen Wahrscheinlichkeit von `top_p`. Gültige Werte: Float, Bereich: 0,0, 1,0. |
| `return_full_text` | Wenn `True`, dann ist der Eingabetext Teil des generierten Ausgabetextes. Zulässige Werte: Boolean, Standard: False. |
Weitere Informationen zur Inferenz von Basismodellen finden Sie unter [Bereitstellen öffentlich verfügbarer Basismodelle mit der `JumpStartModel`-Klasse](jumpstart-foundation-models-use-python-sdk-model-class.md).
Wenn Prompt-Engineering nicht ausreicht, um Ihr Grundlagenmodell an spezifische Geschäftsanforderungen, domainspezifische Sprache, Zielaufgaben oder andere Anforderungen anzupassen, können Sie erwägen, Ihr Modell anhand zusätzlicher Daten zu optimieren oder Retrieval Augmented Generation (RAG) zu verwenden, um Ihre Modellarchitektur mit erweitertem Kontext aus archivierten Wissensquellen zu verbessern. Für weitere Informationen siehe [Basismodelle und Hyperparameter für die Optimierung](jumpstart-foundation-models-fine-tuning.md) oder [Retrieval Augmented Generation](jumpstart-foundation-models-customize-rag.md).
# Basismodelle und Hyperparameter für die Optimierung
Grundlagenmodelle sind rechenintensiv und werden auf einem großen, unbeschrifteten Datensatz trainiert. Die Feinabstimmung eines vortrainierten Grundlagenmodells ist eine kostengünstige Möglichkeit, die vielfältigen Funktionen des Modells zu nutzen und ein Modell gleichzeitig an Ihren eigenen kleinen Datensatz anzupassen. Die Feinabstimmung ist eine Anpassungsmethode, die weiteres Training erfordert und die Gewichtung Ihres Modells verändert.
Die Feinabstimmung kann für Sie nützlich sein, wenn:
+ Sie Ihr Modell an spezifische Geschäftsanforderungen anpassen müssen.
+ Ihr Modell erfolgreich mit domainspezifischer Sprache wie Branchenjargon, Fachbegriffen oder anderem Fachvokabular arbeiten soll.
+ Sie für bestimmte Aufgaben eine bessere Leistung benötigen.
+ Sie in Anwendungen genaue, relative und kontextsensitive Antworten benötigen.
+ Sie Antworten benötigen, die sachlicher, weniger toxisch und besser auf spezifische Anforderungen zugeschnitten sind.
Es gibt zwei Hauptansätze, die Sie je nach Anwendungsfall und ausgewähltem Grundlagenmodell für die Feinabstimmung wählen können.
1. Wenn Sie daran interessiert sind, Ihr Modell anhand domainspezifischer Daten zu optimieren, finden Sie weitere Informationen unter [Optimieren eines großen Sprachmodells (LLM) mithilfe von Domainanpassung](jumpstart-foundation-models-fine-tuning-domain-adaptation.md).
1. Wenn Sie an einer anweisungsbasierten Feinabstimmung anhand von Beispielen für Eingabeaufforderungen und Antworten interessiert sind, finden Sie weitere Informationen unter [Optimieren eines großen Sprachmodells (LMM) mit Prompt-Anweisungen](jumpstart-foundation-models-fine-tuning-instruction-based.md).
## Verfügbare Basismodelle für die Optimierung
Sie können jedes der folgenden JumpStart Foundation-Modelle verfeinern:
+ Bloom 3B
+ Bloom 7B1
+ BloomZ 3B FP16
+ BloomZ 7 B1 FP16
+ Code Llama 13B
+ Code Llama 13B Python
+ Code Llama 34B
+ Code Llama 34B Python
+ Code Llama 70B
+ Code Llama 70B Python
+ Code Llama 7B
+ Code Llama 7B Python
+ CyberAgentLM2-7B-Chat (-7B-Chat) CALM2
+ Falke 40 B BF16
+ Falcon 40B, einweisen BF16
+ Falcon 7B BF16
+ Falcon 7B, instruieren BF16
+ FLAN-T5 Base
+ FLAN-T5 Large
+ FLAN-T5 Small
+ FLAN-T5 XL
+ Flan-T5 XXL
+ Gemma 2B
+ Gemma 2B Instruct
+ Gemma 7B
+ Gemma 7B Instruct
+ GPT-2 XL
+ GPT-J 6B
+ GPT-Neo 1.3B
+ GPT-Neo 125M
+ GPT-NEO 2.7B
+ LightGPT Instruct 6B
+ Llama 2 13B
+ Llama 2 13B Chat
+ Llama 2 13B Neuron
+ Llama 2 70B
+ Llama 2 70B Chat
+ Llama 2 7B
+ Llama 2 7B Chat
+ Llama 2 7B Neuron
+ Mistral 7B
+ Mixtral 8x7B
+ Mixtral 8x7B Instruct
+ RedPajama INCITE Basis 3B V1
+ RedPajama INCITE Basis 7B V1
+ RedPajama INCITE Chat 3B V1
+ RedPajama INCITE Chat 7B V1
+ RedPajama INCITE instruiere 3B V1
+ RedPajama INCITE, Instruktiv 7B V1
+ Stabile Diffusion 2.1
## Häufig unterstützte Hyperparameter bei der Optimierung
Verschiedene Basismodelle unterstützen bei der Optimierung unterschiedliche Hyperparameter. Die folgenden Hyperparameter, mit denen Sie Ihr Modell während des Trainings weiter anpassen können, werden häufig unterstützt:
| Inferenzparameter | Description |
| --- | --- |
| `epoch` | Die Anzahl der Durchläufe, die das Modell während des Trainings durch den Datensatz zur Optimierung durchläuft Muss eine Ganzzahl größer als 1 sein. |
| `learning_rate` | Die Geschwindigkeit, mit der die Modellgewichte aktualisiert werden, nachdem die einzelnen Trainingsbeispiele zur Optimierung durchgearbeitet wurden. Muss ein positiver Gleitkommawert größer als 0 sein. |
| `instruction_tuned` | Ob das Modell per Anweisung trainiert werden soll oder nicht. Es muss sich entweder um `'True'` oder `'False'` handeln. |
| `per_device_train_batch_size` | Die Batchgröße pro GPU-Kern oder CPU für das Training. Muss eine positive Ganzzahl sein. |
| `per_device_eval_batch_size` | Die Batchgröße pro GPU-Kern oder CPU für die Bewertung. Muss eine positive Ganzzahl sein. |
| `max_train_samples` | Kürzen Sie die Anzahl der Trainingsbeispiele zum Debuggen oder für ein schnelleres Training auf diesen Wert. Der Wert -1 bedeutet, dass das Modell alle Trainingsbeispiele verwendet. Muss eine positive Ganzzahl oder -1 sein. |
| `max_val_samples` | Kürzen Sie die Anzahl der Validierungsbeispiele zum Debuggen oder für ein schnelleres Training auf diesen Wert. Der Wert -1 bedeutet, dass das Modell alle Validierungsbeispiele verwendet. Muss eine positive Ganzzahl oder -1 sein. |
| `max_input_length` | Maximale Gesamtlänge der Eingabesequenz nach der Tokenisierung. Sequenzen, die länger sind, werden gekürzt. Wenn -1, wird `max_input_length` auf das Minimum von 1024 gesetzt und `model_max_length` wird vom Tokenizer definiert. Wenn der Wert positiv ist, wird `max_input_length` auf das Minimum des angegebenen Werts gesetzt und `model_max_length` wird vom Tokenizer definiert. Muss eine positive Ganzzahl oder -1 sein. |
| `validation_split_ratio` | Verhältnis von Trainings- und Validierungsdaten, in die die Trainingsdaten aufgeteilt wurden, wenn es keinen Validierungskanal gibt. Muss zwischen 0 und 1 liegen. |
| `train_data_split_seed` | Verhindert die zufällige Aufteilung der eingegebenen Trainingsdaten in die vom Modell verwendeten Trainings- und Validierungsdaten, wenn keine Validierungsdaten vorhanden sind. Muss eine Ganzzahl sein. |
| `preprocessing_num_workers` | Die Anzahl der Prozesse, die für die Vorverarbeitung verwendet werden sollen. Wenn `None`, wird der Hauptprozess für die Vorverarbeitung verwendet. |
| `lora_r` | LoRA-Wert (Low-Rank Adaptation), der als Skalierungsfaktor für die Aktualisierung von Gewichtungen dient. Muss eine positive Ganzzahl sein. |
| `lora_alpha` | Alpha-Wert für LoRA (Low-Rank Adaptation), der als Skalierungsfaktor für die Aktualisierung von Gewichtungen dient. Im Allgemeinen das 2- bis 4-Fache der Größe von `lora_r`. Muss eine positive Ganzzahl sein. |
| `lora_dropout` | Der Dropout-Wert für LoRA-Schichten (Low-Rank Adaptation). Muss ein positiver Gleitkommawert zwischen 0 und 1 sein. |
| `int8_quantization` | Wenn `True`, wird das Modell für das Training mit einer Genauigkeit von 8 Bit geladen. |
| `enable_fsdp` | Wenn `True`, wird beim Training Fully Sharded Data Parallelism verwendet. |
Sie können Hyperparameterwerte angeben, wenn Sie Ihr Modell in Studio optimieren. Weitere Informationen finden Sie unter [Optimieren eines Modells in Studio](jumpstart-foundation-models-use-studio-updated-fine-tune.md).
Sie können bei der Feinabstimmung Ihres Modells mit dem SDK auch Standard-Hyperparameterwerte überschreiben. SageMaker Python Weitere Informationen finden Sie unter [Optimieren von öffentlich verfügbaren Basismodellen mit der `JumpStartEstimator`-Klasse](jumpstart-foundation-models-use-python-sdk-estimator-class.md).
# Optimieren eines großen Sprachmodells (LLM) mithilfe von Domainanpassung
Die Feinabstimmung der Domainanpassung ermöglicht es Ihnen, vortrainierte Grundlagenmodelle zu nutzen und sie mithilfe begrenzter domainspezifischer Daten an bestimmte Aufgaben anzupassen. Wenn Prompt-Engineering nicht zu einer ausreichenden Anpassung führen, können Sie die Feinabstimmung der Domainanpassung verwenden, damit Ihr Modell mit domainspezifischer Sprache wie Branchenjargon, Fachbegriffen oder anderen Fachdaten arbeiten kann. Durch diesen Feinabstimmungsprozess werden die Gewichtungen des Modells geändert.
So optimieren Sie Ihr Modell anhand eines Domain-spezifischen Datensatzes:
1. Bereiten Sie Ihre Trainingsdaten vor. Detaillierte Anweisungen finden Sie unter [Vorbereiten und Hochladen von Trainingsdaten zur Optimierung für die Domain](#jumpstart-foundation-models-fine-tuning-domain-adaptation-prepare-data).
1. Erstellen Sie Ihren Trainingsjob zur Optimierung. Detaillierte Anweisungen finden Sie unter [Erstellen eines Trainingsjobs zur Optimierung mithilfe von Anweisungen](#jumpstart-foundation-models-fine-tuning-domain-adaptation-train).
end-to-endBeispiele finden Sie unter. [Beispiel-Notebooks](#jumpstart-foundation-models-fine-tuning-domain-adaptation-examples)
Die Feinabstimmung der Domainanpassung ist für die folgenden Grundlagenmodelle verfügbar:
**Anmerkung**
Einige JumpStart Basismodelle, wie Llama 2 7B, erfordern die Annahme einer Endbenutzer-Lizenzvereinbarung, bevor die Feinabstimmung vorgenommen und Inferenzen durchgeführt werden können. Weitere Informationen finden Sie unter [Endbenutzer-Lizenzvereinbarungen](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula).
+ Bloom 3B
+ Bloom 7B1
+ BloomZ 3B FP16
+ BloomZ 7 B1 FP16
+ GPT-2 XL
+ GPT-J 6B
+ GPT-Neo 1.3B
+ GPT-Neo 125M
+ GPT-NEO 2.7B
+ Llama 2 13B
+ Llama 2 13B Chat
+ Llama 2 13B Neuron
+ Llama 2 70B
+ Llama 2 70B Chat
+ Llama 2 7B
+ Llama 2 7B Chat
+ Llama 2 7B Neuron
## Vorbereiten und Hochladen von Trainingsdaten zur Optimierung für die Domain
Trainingsdaten zur Optimierung für die Domain können im CSV-, JSON- oder TXT-Dateiformat bereitgestellt werden. Alle Trainingsdaten müssen sich in einer einzigen Datei in einem einzigen Ordner befinden.
Die Trainingsdaten stammen aus der **Textspalte** für CSV- oder JSON-Trainingsdatendateien. Wenn keine Spalte mit **Text** gekennzeichnet ist, werden die Trainingsdaten aus der ersten Spalte für CSV- oder JSON-Trainingsdatendateien übernommen.
Im Folgenden finden Sie ein Beispiel für den Hauptteil einer TXT-Datei, die zur Optimierung verwendet werden soll:
```
This report includes estimates, projections, statements relating to our
business plans, objectives, and expected operating results that are “forward-
looking statements” within the meaning of the Private Securities Litigation
Reform Act of 1995, Section 27A of the Securities Act of 1933, and Section 21E
of ....
```
### Aufteilen von Daten zu Trainings- und Testzwecken
Sie können optional einen weiteren Ordner mit Validierungsdaten bereitstellen. Dieser Ordner sollte auch eine CSV-, JSON- oder TXT-Datei enthalten. Wenn kein Validierungsdatensatz bereitgestellt wird, wird eine festgelegte Menge der Trainingsdaten für Validierungszwecke reserviert. Bei der Auswahl der Hyperparameter für die Optimierung Ihres Modells können Sie den Prozentsatz der für die Validierung verwendeten Trainingsdaten anpassen.
### Hochladen von Optimierungsdaten in Amazon S3
Laden Sie Ihre vorbereiteten Daten in Amazon Simple Storage Service (Amazon S3) hoch, um sie bei der Feinabstimmung eines JumpStart Basismodells zu verwenden. Sie können zum Hochladen Ihre Daten die folgenden Befehle verwenden:
```
from sagemaker.s3 import S3Uploader
import sagemaker
import random
output_bucket = sagemaker.Session().default_bucket()
local_data_file = "train.txt"
train_data_location = f"s3://{output_bucket}/training_folder"
S3Uploader.upload(local_data_file, train_data_location)
S3Uploader.upload("template.json", train_data_location)
print(f"Training data: {train_data_location}")
```
## Erstellen eines Trainingsjobs zur Optimierung mithilfe von Anweisungen
Nachdem Ihre Daten auf Amazon S3 hochgeladen wurden, können Sie Ihr JumpStart Basismodell optimieren und bereitstellen. Informationen zur Optimierung Ihres Modells in Studio finden Sie unter [Optimieren eines Modells in Studio](jumpstart-foundation-models-use-studio-updated-fine-tune.md). Informationen zur Feinabstimmung Ihres Modells mithilfe des SageMaker Python SDK finden Sie unter. [Optimieren von öffentlich verfügbaren Basismodellen mit der `JumpStartEstimator`-Klasse](jumpstart-foundation-models-use-python-sdk-estimator-class.md)
## Beispiel-Notebooks
Weitere Informationen zur Optimierung für die Domain finden Sie in den folgenden Beispiel-Notebooks:
+ [SageMaker JumpStart Foundation Models — Feinabstimmung des GPT-J 6B-Modells zur Textgenerierung anhand eines domänenspezifischen Datensatzes](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/domain-adaption-finetuning-gpt-j-6b.html)
+ [Feinabstimmung LLa von MA 2-Modellen auf JumpStart](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/llama-2-finetuning.html)
# Optimieren eines großen Sprachmodells (LMM) mit Prompt-Anweisungen
Bei der anweisungsbasierten Feinabstimmung werden gekennzeichnete Beispiele verwendet, um die Leistung eines vortrainierten Grundlagenmodells für eine bestimmte Aufgabe zu verbessern. Die gekennzeichneten Beispiele sind als Eingabeaufforderung und Antwortpaare formatiert und als Anweisungen formuliert. Durch diesen Feinabstimmungsprozess werden die Gewichtungen des Modells geändert. Weitere Informationen zur anweisungsbasierten Feinabstimmung finden Sie in den Artikeln [Introducing FLAN: More generalizable Language Models with Instruction Fine-Tuning](https://ai.googleblog.com/2021/10/introducing-flan-more-generalizable.html) und [Scaling Instruction-Finetuned Language Models](https://arxiv.org/abs/2210.11416).
FLAN (Fine-Tuned LAnguage Net) -Modelle nutzen die Befehlsoptimierung, um Modelle für die Lösung allgemeiner nachgelagerter NLP-Aufgaben besser geeignet zu machen. Amazon SageMaker JumpStart bietet eine Reihe von Basismodellen in der FLAN-Modellfamilie an. Bei den FLAN-T5-Modellen sind die Anweisungen beispielsweise auf eine Vielzahl von Aufgaben abgestimmt, um die Zero-Shot-Leistung für eine Vielzahl gängiger Anwendungsfälle zu erhöhen. Mit zusätzlichen Daten und Feinabstimmungen können anweisungsbasierte Modelle weiter an spezifischere Aufgaben angepasst werden, die beim Vortraining nicht berücksichtigt wurden.
So optimieren Sie ein LLM für eine bestimmte Aufgabe mithilfe von Anweisungen in Form von Prompt-Antwort-Paaren:
1. Bereiten Sie Ihre Anweisungen in JSON-Dateien vor. Weitere Informationen zum erforderlichen Format für die Dateien mit den Prompt-Antwort-Paaren und zur Struktur des Datenordners finden Sie unter [Vorbereiten und Hochladen von Trainingsdaten für die Optimierung mithilfe von Anweisungen](#jumpstart-foundation-models-fine-tuning-instruction-based-prepare-data).
1. Erstellen Sie Ihren Trainingsjob zur Optimierung. Detaillierte Anweisungen finden Sie unter [Erstellen eines Trainingsjobs zur Optimierung mithilfe von Anweisungen](#jumpstart-foundation-models-fine-tuning-instruction-based-train).
end-to-endBeispiele finden Sie in[Beispiel-Notebooks](#jumpstart-foundation-models-fine-tuning-instruction-based-examples).
Nur ein Teil der Basismodelle ist mit JumpStart der anweisungsbasierten Feinabstimmung kompatibel. Die anweisungsbasierte Feinabstimmung ist für die folgenden Grundlagenmodelle verfügbar:
**Anmerkung**
Einige Basismodelle JumpStart , wie Llama 2 7B, erfordern die Annahme einer Endbenutzer-Lizenzvereinbarung, bevor die Feinabstimmung vorgenommen und Inferenzen durchgeführt werden können. Weitere Informationen finden Sie unter [Endbenutzer-Lizenzvereinbarungen](jumpstart-foundation-models-choose.md#jumpstart-foundation-models-choose-eula).
+ FLAN-T5 Base
+ FLAN-T5 Large
+ FLAN-T5 Small
+ FLAN-T5 XL
+ Flan-T5 XXL
+ Llama 2 13B
+ Llama 2 13B Chat
+ Llama 2 13B Neuron
+ Llama 2 70B
+ Llama 2 70B Chat
+ Llama 2 7B
+ Llama 2 7B Chat
+ Llama 2 7B Neuron
+ Mistral 7B
+ RedPajama INCITE Base 3B V1
+ RedPajama INCITE Basis 7B V1
+ RedPajama INCITE Chat 3B V1
+ RedPajama INCITE Chat 7B V1
+ RedPajama INCITE instruiere 3B V1
+ RedPajama INCITE, Instruktiv 7B V1
## Vorbereiten und Hochladen von Trainingsdaten für die Optimierung mithilfe von Anweisungen
Trainingsdaten für die Optimierung mithilfe von Anweisungen müssen im Textdateiformat JSON Lines bereitgestellt werden, wobei jede Zeile ein Wörterbuch ist. Alle Trainingsdaten müssen sich in einem einzigen Ordner befinden. Der Ordner kann mehrere JSONL-Dateien enthalten.
Der Trainingsordner kann auch eine JSON-Vorlagendatei (`template.json`) enthalten, die die Eingabe- und Ausgabeformate Ihrer Daten beschreibt. Wenn keine Vorlagendatei bereitgestellt wird, wird die folgende Vorlagendatei verwendet:
```
{
"prompt": "Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.\n\n### Instruction:\n{instruction}\n\n### Input:\n{context}",
"completion": "{response}"
}
```
Gemäß der `template.json`-Datei muss jeder JSONL-Eintrag der Trainingsdaten die Felder `{instruction}`, `{context}` und `{response}` enthalten.
Wenn Sie eine benutzerdefinierte JSON-Vorlagendatei bereitstellen, verwenden Sie die Tasten `"completion"` und `"prompt"`, um Ihre eigenen Pflichtfelder zu definieren. Gemäß der folgenden benutzerdefinierten JSON-Vorlagendatei muss jeder JSONL-Eintrag der Trainingsdaten die Felder `{question}`, `{context}` und `{answer}` enthalten:
```
{
"prompt": "question: {question} context: {context}",
"completion": "{answer}"
}
```
### Aufteilen von Daten zu Trainings- und Testzwecken
Sie können optional einen weiteren Ordner mit Validierungsdaten bereitstellen. Dieser Ordner sollte auch eine oder mehrere JSONL-Dateien enthalten. Wenn kein Validierungsdatensatz bereitgestellt wird, wird eine festgelegte Menge der Trainingsdaten für Validierungszwecke reserviert. Bei der Auswahl der Hyperparameter für die Optimierung Ihres Modells können Sie den Prozentsatz der für die Validierung verwendeten Trainingsdaten anpassen.
### Hochladen von Optimierungsdaten in Amazon S3
Laden Sie Ihre vorbereiteten Daten in Amazon Simple Storage Service (Amazon S3) hoch, um sie bei der Feinabstimmung eines JumpStart Basismodells zu verwenden. Sie können zum Hochladen Ihre Daten die folgenden Befehle verwenden:
```
from sagemaker.s3 import S3Uploader
import sagemaker
import random
output_bucket = sagemaker.Session().default_bucket()
local_data_file = "train.jsonl"
train_data_location = f"s3://{output_bucket}/dolly_dataset"
S3Uploader.upload(local_data_file, train_data_location)
S3Uploader.upload("template.json", train_data_location)
print(f"Training data: {train_data_location}")
```
## Erstellen eines Trainingsjobs zur Optimierung mithilfe von Anweisungen
Nachdem Ihre Daten auf Amazon S3 hochgeladen wurden, können Sie Ihr JumpStart Basismodell optimieren und bereitstellen. Informationen zur Optimierung Ihres Modells in Studio finden Sie unter [Optimieren eines Modells in Studio](jumpstart-foundation-models-use-studio-updated-fine-tune.md). Informationen zur Feinabstimmung Ihres Modells mithilfe des SageMaker Python SDK finden Sie unter. [Optimieren von öffentlich verfügbaren Basismodellen mit der `JumpStartEstimator`-Klasse](jumpstart-foundation-models-use-python-sdk-estimator-class.md)
## Beispiel-Notebooks
Weitere Informationen zur Optimierung mithilfe von Anweisungen finden Sie in den folgenden Beispiel-Notebooks:
+ [Optimieren Sie LLa MA 2-Modelle auf JumpStart](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/llama-2-finetuning.html)
+ [Einführung in SageMaker JumpStart — Textgenerierung mit Mistral-Modellen](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/mistral-7b-instruction-domain-adaptation-finetuning.html)
+ [Einführung in SageMaker JumpStart — Textgenerierung mit Falcon-Modellen](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/falcon-7b-instruction-domain-adaptation-finetuning.html)
+ [SageMaker JumpStart Foundation Models — Feinabstimmung von HuggingFace Text2Text-Befehlen](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/instruction-fine-tuning-flan-t5.html)
# Retrieval Augmented Generation
Grundlagenmodelle werden normalerweise offline trainiert, wodurch das Modell unabhängig von allen Daten ist, die nach dem Training des Modells erstellt wurden. Darüber hinaus werden Grundlagenmodelle mit sehr allgemeinen Domaindatensätzen trainiert, wodurch sie für domainspezifische Aufgaben weniger effektiv sind. Mit Retrieval Augmented Generation (RAG) können Sie Daten von außerhalb eines Grundlagenmodells abrufen und Ihre Eingabeaufforderungen erweitern, indem Sie die relevanten abgerufenen Daten im Kontext hinzufügen. Weitere Informationen zu RAG-Modellarchitekturen finden Sie unter [Retrieval-Augmented Generation für wissensintensive NLP-Aufgaben](https://arxiv.org/abs/2005.11401).
Mit RAG können die externen Daten, die zur Erweiterung Ihrer Eingabeaufforderungen verwendet werden, aus mehreren Datenquellen stammen, z. B. aus Dokumentablagen, Datenbanken oder. APIs Der erste Schritt besteht darin, Ihre Dokumente und alle Benutzerabfragen in ein kompatibles Format zu konvertieren, um eine Relevanzsuche durchzuführen. Um die Formate kompatibel zu machen, werden eine Dokumentensammlung oder Wissensbibliothek und von Benutzern eingereichte Abfragen mithilfe von eingebetteten Sprachmodellen in numerische Darstellungen konvertiert. Beim *Einbetten* wird Text in einem Vektorraum numerisch dargestellt. RAG-Modellarchitekturen vergleichen die Einbettungen von Benutzerabfragen innerhalb des Vektors der Wissensbibliothek. Die ursprüngliche Eingabeaufforderung wird dann mit relevantem Kontext aus ähnlichen Dokumenten in der Wissensbibliothek angehängt. Diese erweiterte Eingabeaufforderung wird dann an das Grundlagenmodell gesendet. Sie können Wissensbibliotheken und ihre relevanten Einbettungen asynchron aktualisieren.
![\[A model architecture diagram of Retrieval Augmented Generation (RAG).\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/jumpstart/jumpstart-fm-rag.jpg)
Das abgerufene Dokument sollte groß genug sein, um nützlichen Kontext zur Erweiterung des Prompts zu enthalten, aber klein genug, um in die maximale Sequenzlänge des Prompts zu passen. Sie können aufgabenspezifische JumpStart Modelle wie das Modell General Text Embeddings (GTE) von verwenden, um die Einbettungen für Ihre Hugging Face Eingabeaufforderungen und Wissensbibliotheksdokumente bereitzustellen. Nachdem Sie den Prompt und die Dokumenteinbettungen verglichen haben, um die relevantesten Dokumente zu finden, erstellen Sie einen neuen Prompt mit dem ergänzenden Kontext. Übergeben Sie dann den erweiterten Prompt an ein Textgenerierungsmodell Ihrer Wahl.
## Beispiel-Notebooks
Weitere Informationen zu Lösungen mit RAG-Basismodellen finden Sie in den folgenden Beispiel-Notebooks:
+ [Retrieval-Augmented Generation: Beantwortung von Fragen mithilfe von Generate- und Einbettungsmodellen von Cohere LangChain SageMaker JumpStart](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_Cohere+langchain_jumpstart.html)
+ [Retrieval-Augmented Generation: Beantwortung von Fragen mit -2, Pinecone und benutzerdefiniertem Datensatz LLama](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_pinecone_llama-2_jumpstart.html)
+ [Retrieval-Augmented Generation: Beantwortung von Fragen auf der Grundlage eines benutzerdefinierten Datensatzes mit Open-Source-Bibliothek LangChain ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_langchain_jumpstart.html)
+ [Retrieval-Augmented Generation: Beantwortung von Fragen auf der Grundlage eines benutzerdefinierten Datensatzes](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_jumpstart_knn.html)
+ [Retrieval-Augmented Generation: Beantwortung von Fragen mithilfe von Llama 2 und Texteinbettungsmodellen](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_text_embedding_llama-2_jumpstart.html)
+ [Amazon SageMaker JumpStart — Texteinbettung und Satzähnlichkeit](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/text-embedding-sentence-similarity.html)
Sie können das [Amazon SageMaker AI-Beispiel-Repository](https://github.com/aws/amazon-sagemaker-examples/tree/main/introduction_to_amazon_algorithms/jumpstart-foundation-models) klonen, um die verfügbaren JumpStart Foundation-Modellbeispiele in der Jupyter-Umgebung Ihrer Wahl in Studio auszuführen. Weitere Informationen zu Anwendungen, mit denen Sie Jupyter in KI erstellen und darauf zugreifen können, finden Sie unter. SageMaker [In Amazon SageMaker Studio unterstützte Anwendungen](studio-updated-apps.md)
# Bewerten eines Basismodells für die Textgenerierung in Studio
**Anmerkung**
Foundation Model Evaluations (FMEval) befindet sich in der Vorschauversion für Amazon SageMaker Clarify und kann sich ändern.
**Wichtig**
Um SageMaker Clarify Foundation Model Evaluations verwenden zu können, müssen Sie ein Upgrade auf das neue Studio-Erlebnis durchführen. Seit dem 30. November 2023 heißt das vorherige Amazon SageMaker Studio-Erlebnis jetzt Amazon SageMaker Studio Classic. Die Foundation-Evaluierungsfunktion kann nur in der aktualisierten Version verwendet werden. Weitere Informationen zur Aktualisierung von Studio finden Sie unter [Migration von Amazon SageMaker Studio Classic](studio-updated-migrate.md). Informationen zur Verwendung der Studio-Classic-Anwendung finden Sie unter [Amazon SageMaker Studio Klassisch](studio.md).
Amazon SageMaker JumpStart bietet Integrationen mit SageMaker Clarify Foundation Model Evaluations (FMEval) in Studio. Wenn für ein JumpStart Modell integrierte Evaluierungsfunktionen verfügbar sind, können Sie in der JumpStart Studio-Benutzeroberfläche in der oberen rechten Ecke der Modelldetailseite die Option **Evaluieren** auswählen. Weitere Informationen zur Navigation in der JumpStart Studio-Benutzeroberfläche finden Sie unter [In Studio öffnen JumpStart](studio-jumpstart.md#jumpstart-open-studio)
Verwenden Sie Amazon SageMaker JumpStart , um textbasierte Fundamentmodelle mit FMEval zu evaluieren. Sie können diese Modellbewertungen verwenden, um Kennzahlen zur Modellqualität und -verantwortung für ein Modell, zwischen zwei Modellen oder zwischen verschiedenen Versionen desselben Modells zu vergleichen, um Modellrisiken zu quantifizieren. FMEval kann textbasierte Modelle auswerten, die die folgenden Aufgaben erfüllen:
+ **Generierung mit offenem Ende** – Die Erzeugung natürlicher menschlicher Antworten auf Text, der keine vordefinierte Struktur hat.
+ **Textzusammenfassung** – Generierung einer präzisen und komprimierten Zusammenfassung unter Beibehaltung der Bedeutung und der wichtigsten Informationen, die in einem größeren Text enthalten sind.
+ **Beantwortung von Fragen** – Generierung einer Antwort in natürlicher Sprache auf eine Frage.
+ **Klassifikation** – Die Zuordnung einer Klasse, z. B. `positive` gegenüber `negative`, zu einer Textstelle auf der Grundlage ihres Inhalts.
Sie können FMEval es verwenden, um Modellantworten auf der Grundlage bestimmter Benchmarks automatisch auszuwerten. Sie können die Modellantworten auch anhand Ihrer eigenen Kriterien auswerten, indem Sie Ihre eigenen Prompt-Datensätze mitbringen. FMEval bietet eine Benutzeroberfläche (UI), die Sie durch die Einrichtung und Konfiguration eines Evaluierungsjobs führt. Sie können die FMEval Bibliothek auch in Ihrem eigenen Code verwenden.
Für jede Bewertung ist ein Kontingent für zwei Instances erforderlich:
+ Hosting-Instance – Eine Instance, die ein LLM hostet und bereitstellt.
+ Bewertungs-Instance – Eine Instance, die verwendet wird, um ein LLM auf der Hosting-Instance anzufordern und zu testen.
Wenn Ihr LLM bereits bereitgestellt ist, geben Sie den Endpunkt an, und SageMaker KI verwendet Ihre **Hosting-Instanz**, um das LLM zu hosten und bereitzustellen.
Wenn Sie ein JumpStart Modell evaluieren, das noch nicht für Ihr Konto bereitgestellt wurde, FMEval erstellt es eine temporäre **Hosting-Instanz** für Sie in Ihrem Konto und behält diese nur für die Dauer Ihrer Evaluierung bei. FMEval verwendet die Standardinstanz, die für das gewählte LLM JumpStart empfohlen wird, als Hosting-Instanz. Sie müssen über ein ausreichendes Kontingent für diese empfohlene Instance verfügen.
Bei jeder Bewertung wird außerdem eine Bewertungs-Instance verwendet, um dem LLM Prompts zu geben und die Antworten zu bewerten. Sie müssen außerdem über ausreichend Kontingent und Arbeitsspeicher verfügen, um die Bewertungsalgorithmen ausführen zu können. Die Kontingent- und Speicheranforderungen der Bewertungs-Instance sind im Allgemeinen geringer als die, die für eine Hosting-Instance erforderlich sind. Wir empfehlen, die `ml.m5.2xlarge`-Instance auszuwählen. Weitere Informationen zu Kontingenten und Speicher finden Sie unter [Fehler bei der Erstellung eines Modellevaluierungsjobs in Amazon SageMaker AI beheben](clarify-foundation-model-evaluate-troubleshooting.md).
Automatische Bewertungen können verwendet werden, um LLMs in den folgenden Dimensionen Punkte zu erzielen:
+ Genauigkeit – für die Textzusammenfassung, Beantwortung von Fragen und Textklassifizierung
+ Semantische Robustheit – für die Generierung mit offenem Ende, Textzusammenfassung und Textklassifizierung
+ Faktenwissen – für die Generierung mit offenem Ende
+ Prompt-Stereotypisierung – für die Generierung mit offenem Ende
+ Toxizität – für die Generierung mit offenem Ende, Textzusammenfassung und Beantwortung von Fragen
Sie können auch menschliche Bewertungen verwenden, um Modellantworten manuell zu bewerten. Die FMEval Benutzeroberfläche führt Sie durch einen Arbeitsablauf, der aus der Auswahl eines oder mehrerer Modelle, der Bereitstellung von Ressourcen und dem Schreiben von Anweisungen für Ihre Mitarbeiter und deren Kontaktaufnahme besteht. Nach Abschluss der Bewertung durch den Mitarbeiter werden die Ergebnisse unter angezeigt. FMEval
Sie können über die JumpStart Landingpage in Studio auf die Modellevaluierung zugreifen, indem Sie ein zu evaluierendes Modell auswählen und dann **Evaluieren** wählen. Beachten Sie, dass nicht für alle JumpStart Modelle Evaluierungsfunktionen verfügbar sind. Weitere Informationen zur Konfiguration, Bereitstellung und Ausführung FMEval finden Sie unter [Was sind Foundation-Model-Evaluierungen?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-foundation-model-evaluate.html)
# Beispiel-Notebooks
step-by-stepBeispiele zur Verwendung öffentlich verfügbarer JumpStart Foundation-Modelle mit dem SageMaker Python SDK finden Sie in den folgenden Notizbüchern zur Textgenerierung, Bildgenerierung und Modellanpassung.
**Anmerkung**
Proprietäre und öffentlich verfügbare JumpStart Foundation-Modelle verfügen über unterschiedliche Workflows zur Bereitstellung von SageMaker Python KI-SDK. Entdecken Sie über Amazon SageMaker Studio Classic oder die SageMaker KI-Konsole Beispiel-Notebooks mit eigenem Foundation-Modell. Weitere Informationen finden Sie unter [JumpStart Verwendung des Foundation-Modells](jumpstart-foundation-models-use.md).
Sie können das [Amazon SageMaker AI-Beispiel-Repository](https://github.com/aws/amazon-sagemaker-examples/tree/main/introduction_to_amazon_algorithms/jumpstart-foundation-models) klonen, um die verfügbaren JumpStart Foundation-Modellbeispiele in der Jupyter-Umgebung Ihrer Wahl in Studio auszuführen. Weitere Informationen zu Anwendungen, mit denen Sie Jupyter in KI erstellen und darauf zugreifen können, finden Sie unter. SageMaker [In Amazon SageMaker Studio unterstützte Anwendungen](studio-updated-apps.md)
## Zeitreihenprognosen
Mit den Chronos-Modellen können Sie Zeitreihendaten vorhersagen. Sie basieren auf der Sprachmodellarchitektur. Verwenden Sie das Notizbuch [Einführung SageMaker JumpStart in Zeitreihenprognosen mit Chronos](https://github.com/aws/amazon-sagemaker-examples/blob/default/%20%20%20%20generative_ai/sm-jumpstart_time_series_forecasting.ipynb), um loszulegen.
Weitere Informationen über die verfügbaren Chronos-Modelle finden Sie unter [Verfügbare Basismodelle](jumpstart-foundation-models-latest.md).
## Textgenerierung
Entdecken Sie Beispiel-Notebooks zur Textgenerierung, einschließlich Anleitungen zu allgemeinen Workflows zur Textgenerierung, mehrsprachiger Textklassifizierung, Batch-Inferenz in Echtzeit, Few-Shot-Lernen, Chatbot-Interaktionen und mehr.
+ [SageMaker JumpStart Foundation Models — HuggingFace Text2Text Generation mit FLAN-T5 XL als Beispiel](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/text2text-generation-flan-t5.html)
+ [SageMaker JumpStart Foundation Models — BloomZ: Mehrsprachige Textklassifizierung, Fragen und Antworten, Codegenerierung, Absatzumformulierung und mehr](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/text2text-generation-bloomz.html)
+ [SageMaker JumpStart Foundation Models — Batch-Transformation mit HuggingFace Text2Text-Generierung und Batch-Inferenz in Echtzeit](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/text2text-generation-Batch-Transform.html)
+ [SageMaker JumpStart Grundlegende Modelle — GPT-J, GPT-Neo — Lernen mit wenigen Klicks](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/text-generation-few-shot-learning.html)
+ [SageMaker JumpStart Grundlegende Modelle — Chatbots](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/text-generation-chatbot.html)
+ [Einführung in die SageMaker JumpStart Textgenerierung mit Mistral-Modellen](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/mistral-7b-instruction-domain-adaptation-finetuning.html)
+ [Einführung in SageMaker JumpStart — Textgenerierung mit Falcon-Modellen](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/falcon-7b-instruction-domain-adaptation-finetuning.html)
## Bildgenerierung
Beginnen Sie mit text-to-image Stable Diffusion-Modellen, lernen Sie, wie Sie ein Inpainting-Modell einsetzen, und experimentieren Sie mit einem einfachen Arbeitsablauf, um Bilder von Ihrem Hund zu erstellen.
+ [Einführung in JumpStart — Text zu Bild](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart_text_to_image/Amazon_JumpStart_Text_To_Image.html)
+ [Einführung in die JumpStart Bildbearbeitung — Stabile Diffusion beim Malen](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart_inpainting/Amazon_JumpStart_Inpainting.html)
+ [Erzeugen lustiger Bilder von Ihrem Hund](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart_text_to_image/custom_dog_image_generator.html)
## Modellanpassung
Manchmal erfordert ein Anwendungsfall eine stärkere Anpassung des Grundlagenmodells für bestimmte Aufgaben. Weitere Informationen zu Ansätzen zur Modellanpassung finden Sie unter [Anpassung des Basismodells](jumpstart-foundation-models-customize.md) oder in einem der folgenden Beispiel-Notebooks.
+ [SageMaker JumpStart Foundation Models — Feinabstimmung des GPT-J 6B-Modells zur Textgenerierung anhand eines domänenspezifischen Datensatzes](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/domain-adaption-finetuning-gpt-j-6b.html)
+ [SageMaker JumpStart Foundation Models — Feinabstimmung von Text2Text-Anweisungen HuggingFace ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/instruction-fine-tuning-flan-t5.html)
+ [Retrieval-Augmented Generation: Beantwortung von Fragen mithilfe von Generate- und Einbettungsmodellen von LangChain und von Cohere SageMaker JumpStart](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_Cohere+langchain_jumpstart.html)
+ [Retrieval-Augmented Generation: Beantwortung von Fragen mit -2, Pinecone und benutzerdefiniertem Datensatz LLama](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_pinecone_llama-2_jumpstart.html)
+ [Retrieval-Augmented Generation: Beantwortung von Fragen auf der Grundlage eines benutzerdefinierten Datensatzes mit Open-Source-Bibliothek LangChain ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_langchain_jumpstart.html)
+ [Retrieval-Augmented Generation: Beantwortung von Fragen auf der Grundlage eines benutzerdefinierten Datensatzes](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_jumpstart_knn.html)
+ [Retrieval-Augmented Generation: Beantwortung von Fragen mithilfe von Llama 2 und Texteinbettungsmodellen](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/question_answering_text_embedding_llama-2_jumpstart.html)
+ [Amazon SageMaker JumpStart — Texteinbettung und Satzähnlichkeit](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/jumpstart-foundation-models/question_answering_retrieval_augmented_generation/text-embedding-sentence-similarity.html)