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.

# Integrierte SageMaker KI-Algorithmen für Textdaten
<a name="algorithms-text"></a>

SageMaker KI bietet Algorithmen, die auf die Analyse von Textdokumenten zugeschnitten sind, die bei der Verarbeitung natürlicher Sprache, der Klassifizierung oder Zusammenfassung von Dokumenten, der Themenmodellierung oder -klassifizierung sowie der Transkription oder Übersetzung von Sprachen verwendet werden.
+ [BlazingText Algorithmus](blazingtext.md) – Eine hochoptimierte Implementierung von Word2VEC und Textklassifizierungsalgorithmen, die sich problemlos auf große Datensätze skalieren lässt. Es ist nützlich für viele nachgelagerte Aufgaben der Verarbeitung natürlicher Sprache (NLP).
+ [Latent Dirichlet Allocation (LDA)-Algorithmus](lda.md)–dieser Algorithmus eignet sich für die Bestimmung von Themen in einer Reihe von Dokumenten. Er ist ein *unüberwachter Algorithmus*, was bedeutet, dass während des Trainings keine Beispieldaten mit Antworten verwendet werden.
+ [Algorithmus für neuronale Themenmodellierung (NTM)](ntm.md)–eine weitere unüberwachte Methode zur Bestimmung von Themen in einer Reihe von Dokumente mithilfe eines neuronalen Netzwerkansatzes.
+ [Object2Vec-Algorithmus](object2vec.md)–ein Allzweck-Algorithmus zur neuronalen Einbettung, der für Empfehlungssysteme, Dokumentenklassifizierung und Satzeinbettung verwendet werden kann.
+ [Sequence-to-Sequence Algorithmus](seq-2-seq.md)–dieser überwachte Algorithmus wird allgemein für neuronale Machine Übersetzung verwendet. 
+ [Textklassifizierung - TensorFlow](text-classification-tensorflow.md)–ein überwachter Algorithmus, der Transfer-Learning mit verfügbaren vortrainierten Modellen für die Textklassifizierung unterstützt. 


| Name des Algorithmus | Kanalname | Trainingseingabemodus | Dateityp | Instance-Klasse | Parallelisierbar | 
| --- | --- | --- | --- | --- | --- | 
| BlazingText | "train" | Datei oder Pipe | Textdatei (ein Satz pro Zeile mit durch Leerzeichen getrennten Token)  | GPU (nur einzelne Instance) oder CPU | Nein | 
| LDA | "train" und (optional) "test" | Datei oder Pipe | recordIO-protobuf oder CSV | CPU (nur einzelne Instance) | Nein | 
| Neural Topic Modeling | "train" und (optional) "validation", "test" oder beides | Datei oder Pipe | recordIO-protobuf oder CSV | GPU oder CPU | Ja | 
| Object2Vec | "train" und (optional) "validation", "test" oder beides | Datei | JSON-Lines  | GPU oder CPU (nur einzelne Instance) | Nein | 
| Seq2Seq Modeling | "train", "validation" und "vocab" | Datei | recordIO-protobuf | GPU (nur einzelne Instance) | Nein | 
| Textklassifizierung - TensorFlow | Training und Validierung | Datei | CSV | CPU oder GPU | Ja (nur für mehrere GPUs auf einer einzigen Instanz) | 

# BlazingText Algorithmus
<a name="blazingtext"></a>

Der Amazon SageMaker BlazingText AI-Algorithmus bietet hochoptimierte Implementierungen der Word2VEC- und Textklassifizierungsalgorithmen. Der Word2vec-Algorithmus ist für viele nachgelagerte natürliche Sprachverarbeitungsaufgaben (Natural Language Processing, NLP) wie z. B. Stimmungsanalyse, Erkennung benannter Entitäten und Maschinenübersetzung nützlich. Die Textklassifizierung ist eine wichtige Aufgabe für Anwendungen, die Web-Suchvorgänge, Informationsabrufe, Rangfolgeneinstufungen und Klassifizierung von Dokumenten durchführen.

Der Word2vec-Algorithmus ordnet Wörter hochwertigen verteilten Vektoren zu. Die resultierende Vektordarstellung eines Wortes wird als *Worteinbettung* bezeichnet. Wörter, die semantisch ähnlich sind, entsprechen Vektoren, die nahe beieinander liegen. Auf diese Weise erfassen Worteinbettungen die semantischen Beziehungen zwischen Wörtern. 

Viele Anwendungen mit natürlicher Sprachverarbeitung (NLP, Natural Language Processing) erlernen Worteinbettungen, indem sie mit großen Sammlungen von Dokumenten trainiert werden. Diese vortrainierten Vektordarstellungen liefern Informationen zur Semantik und zu den Wortverteilungen, was in der Regel die Generalisierung anderer Modelle verbessert, die später mit einer eher begrenzten Datenmenge trainiert werden. Die meisten Implementierungen des Word2vec-Algorithmus sind nicht für Multi-Core-CPU-Architekturen optimiert. Auf diese Weise lassen sich große Datensätze nur schwer skalieren. 

Mit dem BlazingText Algorithmus können Sie problemlos auf große Datensätze skalieren. Ähnlich wie Word2VEC bietet es die Trainingsarchitekturen Skip-Gram und Continuous bag-of-words (CBOW). BlazingText[Die Implementierung des überwachten Algorithmus zur Klassifizierung von Text mit mehreren Klassen und mehreren Bezeichnungen erweitert den FastText-Textklassifikator um die Verwendung von GPU-Beschleunigung mit benutzerdefinierten CUDA-Kerneln.](https://docs.nvidia.com/cuda/index.html) Sie können ein Modell mit mehr als eine Milliarde Wörter in wenigen Minuten mithilfe einer Multi-Core-CPU oder GPU trainieren. Und Sie erreichen eine Leistung, die mit den Deep-Learning-Textklassifizierungsalgorithmen ebenbürtig ist state-of-the-art.

Der BlazingText Algorithmus ist nicht parallelisierbar. Weitere Informationen zu Trainingsparametern finden Sie unter [Docker-Registrierungspfade für SageMaker ](https://docs.aws.amazon.com/en_us/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html) integrierte Algorithmen.

 Die SageMaker BlazingText KI-Algorithmen bieten die folgenden Funktionen:
+ Beschleunigtes Training des FastText-Textklassifikators auf Multi-Core CPUs - oder GPU und Word2Vec bei der GPUs Verwendung hochoptimierter CUDA-Kernel. Weitere Informationen finden Sie unter [BlazingText:](https://dl.acm.org/citation.cfm?doid=3146347.3146354) Skalieren und Beschleunigen von Word2Vec mit mehreren. GPUs
+ [Angereicherte Wortvektoren mit Teilwortinformationen](https://arxiv.org/abs/1607.04606) durch Erlernen von Vektordarstellungen für N-Gramm-Zeichen. Dieser Ansatz ermöglicht es BlazingText , aussagekräftige Vektoren für out-of-vocabulary (OOV) -Wörter zu generieren, indem deren Vektoren als Summe der Zeichen-N-Gramm-Vektoren (Teilwort-Vektoren) dargestellt werden.
+ Ein `batch_skipgram` `mode` für den Word2Vec-Algorithmus, mit dem schnellere Trainings und verteilte Berechnungen auf mehreren CPU-Knoten möglich sind. Das `batch_skipgram` `mode` führt eine Mini-Stapelverarbeitung mithilfe der Strategie des Austauschs von Negativbeispielen zum Konvertieren von BLAS-Operationen der ersten Ebene in BLAS-Operationen der dritten Ebene durch. Damit werden die Anweisungen zum Multiplizieren und Hinzufügen moderner Architekturen effizient genutzt. Weitere Informationen finden Sie unter [Parallelizing Word2Vec in Shared und Distributed-Memory](https://arxiv.org/pdf/1604.04661.pdf).

Zusammenfassend lässt sich sagen, dass die folgenden Modi von BlazingText Instanzen verschiedener Typen unterstützt werden:


| Modi |  Word2Vec (Unüberwachtes Lernen)  |  Textklassifizierung (Überwachtes Lernen)  | 
| --- | --- | --- | 
|  Einzelne CPU-Instance  |  `cbow` `Skip-gram` `Batch Skip-gram`  |  `supervised`  | 
|  Einzelne GPU-Instanz (mit einer oder mehreren GPUs)  |  `cbow` `Skip-gram`  |  `supervised` mit einer GPU  | 
|  Mehrere CPU-Instances  | Batch Skip-gram  | Keine | 

Weitere Informationen zur Mathematik, die dahinter steckt BlazingText, finden Sie unter [BlazingText: Skalieren und Beschleunigen von Word2Vec](https://dl.acm.org/citation.cfm?doid=3146347.3146354) mit Multiple. GPUs

**Topics**
+ [

## Eingabe-/Ausgabeschnittstelle für den Algorithmus BlazingText
](#bt-inputoutput)
+ [

## Empfehlung für eine EC2-Instanz für den Algorithmus BlazingText
](#blazingtext-instances)
+ [

## BlazingText Beispiel-Notizbücher
](#blazingtext-sample-notebooks)
+ [

# BlazingText Hyperparameter
](blazingtext_hyperparameters.md)
+ [

# Optimieren Sie ein Modell BlazingText
](blazingtext-tuning.md)

## Eingabe-/Ausgabeschnittstelle für den Algorithmus BlazingText
<a name="bt-inputoutput"></a>

Der BlazingText Algorithmus erwartet eine einzelne vorverarbeitete Textdatei mit durch Leerzeichen getrennten Token. Jede Zeile in der Datei enthält einen einzelnen Satz. Wenn Sie mehrere Textdateien trainieren, verketten Sie sie in einer Datei und laden Sie die Datei in den jeweiligen Kanal hoch.

### Trainings- und Validierungsdatenformat
<a name="blazingtext-data-formats"></a>

#### Trainings- und Validierungsdatenformat für den Word2Vec-Algorithmus
<a name="blazingtext-data-formats-word2vec"></a>

Für Word2Vec-Trainings laden Sie die Datei unter dem *train*-Kanal hoch. Andere Kanäle werden nicht unterstützt. Die Datei enthält einen einzelnen Trainingssatz pro Zeile.

#### Trainings- und Validierungsdatenformat für den Textklassifizierungsalgorithmus
<a name="blazingtext-data-formats-text-class"></a>

Im Rahmen des beaufsichtigten Modus können Sie im Dateimodus oder im erweiterten Manifesttextformat trainieren.

##### Trainieren im Dateimodus
<a name="blazingtext-data-formats-text-class-file-mode"></a>

Für den `supervised` Modus sollte die training/validation Datei einen Trainingssatz pro Zeile zusammen mit den Beschriftungen enthalten. Bezeichnungen sind Wörter, denen die Zeichenfolge *\$1\$1label\$1\$1* vorangestellt ist. Hier ist ein Beispiel für eine training/validation Datei:

```
__label__4  linux ready for prime time , intel says , despite all the linux hype , the open-source movement has yet to make a huge splash in the desktop market . that may be about to change , thanks to chipmaking giant intel corp .

__label__2  bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly as the indian skippers return to international cricket was short lived .
```

**Anmerkung**  
Die Reihenfolge der Bezeichnungen innerhalb des Satzes ist unerheblich. 

Laden Sie das Trainingsdatei unter dem Trainingskanal hoch. Die Validierungsdatei können Sie optional unter dem Validierungskanal hochladen.

##### Schulen im erweiterten Manifesttextformat
<a name="blazingtext-data-formats-text-class-augmented-manifest"></a>

Der überwachte Modus für CPU-Instances unterstützt auch das erweiterte Manifestformat, mit dem Sie im Pipe-Modus trainieren können, ohne RecordIO-Dateien erstellen zu müssen. Bei der Verwendung dieses Formats muss eine S3-Manifestdatei generiert werden, die die Liste der Sätze und ihre entsprechenden Bezeichnungen enthält. Das Manifestdateiformat sollte im [JSON Lines](http://jsonlines.org/)-Format vorliegen, bei dem jede Zeile ein Muster darstellt. Die Sätze werden unter Verwendung des `source`-Tags angegeben und die Bezeichnung kann mithilfe des `label`-Tags angegeben werden. Die – `source`und `label`-Tags sollten beide unter dem `AttributeNames`-Parameterwert bereitgestellt werden, wie in der Anforderung angegeben.

```
{"source":"linux ready for prime time , intel says , despite all the linux hype", "label":1}
{"source":"bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly", "label":2}
```

Multi-Label-Training wird auch durch die Angabe eines JSON-Arrays von Labels unterstützt.

```
{"source":"linux ready for prime time , intel says , despite all the linux hype", "label": [1, 3]}
{"source":"bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly", "label": [2, 4, 5]}
```

Weitere Informationen zu erweiterten Manifestdateien finden Sie unter [Erweiterte Manifestdateien für Trainingsjobs](augmented-manifest.md).

### Modellartefakte und Inferenz
<a name="blazingtext-artifacts-inference"></a>

#### Modellartefakte für den Word2Vec-Algorithmus
<a name="blazingtext--artifacts-inference-word2vec"></a>

Für das Word2Vec-Training bestehen die Modellartefakte aus *vectors.txt*, die words-to-vectors Mapping enthält, und *vectors.bin*, einer Binärdatei, die von BlazingText für Hosting, Inferenz oder beides verwendet wird. *vectors.txt* speichert die Vektoren in einem Format, das mit anderen Tools wie Gensim und Spacy kompatibel ist. Beispiel: Ein Gensim-Benutzer kann die folgenden Befehle zum Laden der Datei vectors.txt ausführen:

```
from gensim.models import KeyedVectors
word_vectors = KeyedVectors.load_word2vec_format('vectors.txt', binary=False)
word_vectors.most_similar(positive=['woman', 'king'], negative=['man'])
word_vectors.doesnt_match("breakfast cereal dinner lunch".split())
```

Wenn der Auswertungsparameter auf `True` festgelegt ist, wird eine zusätzliche Datei, *eval.json*, erstellt. Diese Datei enthält die Ergebnisse der Ähnlichkeitsauswertung (unter Verwendung der Rangkorrelationskoeffizienten von Spearman) im WS-353-Datensatz. Die Anzahl der Wörter aus dem WS-353-Datensatz, die im Trainingsdatensatz nicht vorhanden waren, werden gemeldet.

Für Inferenzanforderungen akzeptiert das Modell eine JSON-Datei mit einer Liste von Zeichenfolgen und gibt eine Liste der Vektoren zurück. Wenn das Wort im Vokabular nicht gefunden wird, gibt die Inferenz einen Vektor mit Nullen zurück. Wenn Teilwörter `True` während des Trainings auf eingestellt sind, ist das Modell in der Lage, Vektoren für out-of-vocabulary (OOV-) Wörter zu generieren.

##### JSON-Beispielanfrage
<a name="word2vec-json-request"></a>

Mime-Typ: ` application/json`

```
{
"instances": ["word1", "word2", "word3"]
}
```

#### Modellartefakte für den Textklassifizierungsalgorithmus
<a name="blazingtext-artifacts-inference-text-class"></a>

Beim Training mit überwachten Ausgaben wird eine Datei *model.bin* erstellt, die vom BlazingText Hosting verwendet werden kann. Als Inferenz akzeptiert das BlazingText Modell eine JSON-Datei, die eine Liste von Sätzen enthält, und gibt eine Liste der entsprechenden vorhergesagten Bezeichnungen und Wahrscheinlichkeitswerte zurück. Jeder Satz muss eine Zeichenfolge mit durch Leerzeichen getrennten Token, Wörtern oder beidem sein.

##### JSON-Beispielanfrage
<a name="text-class-json-request"></a>

Mime-Typ: ` application/json`

```
{
 "instances": ["the movie was excellent", "i did not like the plot ."]
}
```

Standardmäßig gibt der Server nur eine Voraussage zurück, und zwar die mit der höchsten Wahrscheinlichkeit. Zum Abrufen der top *k*-Voraussagen können Sie*k* in der Konfiguration wie folgt festlegen:

```
{
 "instances": ["the movie was excellent", "i did not like the plot ."],
 "configuration": {"k": 2}
}
```

Denn BlazingText die `accept` Parameter ` content-type` und müssen gleich sein. Für die Stapeltransformation müssen beide `application/jsonlines` lauten. Wenn sie sich voneinander unterscheiden, wird das Feld `Accept` ignoriert. Das Format für die Eingabe lautet wie folgt:

```
content-type: application/jsonlines

{"source": "source_0"}
{"source": "source_1"}

if you need to pass the value of k for top-k, then you can do it in the following way:

{"source": "source_0", "k": 2}
{"source": "source_1", "k": 3}
```

Das Format für die Ausgabe lautet wie folgt:

```
accept: application/jsonlines


{"prob": [prob_1], "label": ["__label__1"]}
{"prob": [prob_1], "label": ["__label__1"]}

If you have passed the value of k to be more than 1, then response will be in this format:

{"prob": [prob_1, prob_2], "label": ["__label__1", "__label__2"]}
{"prob": [prob_1, prob_2], "label": ["__label__1", "__label__2"]}
```

Sowohl im überwachten Modus (Textklassifizierung) als auch im unbeaufsichtigten Modus (Word2Vec) BlazingText können die von erstellten Binärdateien (*\$1.bin*) von FastText übergreifend konsumiert werden und umgekehrt. Sie können von FastText BlazingText erstellte Binärdateien verwenden. Ebenso können Sie die mit FastText erstellten Modellbinärdateien mithilfe von hosten. BlazingText

Hier ist ein Beispiel für die Verwendung eines BlazingText mit FastText generierten Modells:

```
#Download the model artifact from S3
aws s3 cp s3://<YOUR_S3_BUCKET>/<PREFIX>/model.tar.gz model.tar.gz

#Unzip the model archive
tar -xzf model.tar.gz

#Use the model archive with fastText
fasttext predict ./model.bin test.txt
```

Die Binärdateien werden jedoch nur beim Training auf CPU und einer einzigen GPU unterstützt; das Training auf mehreren GPUs erzeugt keine Binärdateien.

## Empfehlung für eine EC2-Instanz für den Algorithmus BlazingText
<a name="blazingtext-instances"></a>

Für `skipgram` Modi `cbow` und BlazingText unterstützt einzelne CPU- und GPU-Instances. Beide Modi unterstützen das Erlernen von `subwords`-Einbettungen. Um die höchste Geschwindigkeit ohne Genauigkeitseinbußen zu erzielen, empfehlen wir die Verwendung einer ml.p3.2xlarge-Instance. 

Für `batch_skipgram` den Modus werden einzelne oder mehrere CPU-Instanzen BlazingText unterstützt. Wenn Sie auf mehreren Instanzen trainieren, legen Sie den Wert des `S3DataDistributionType` Felds des [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html)Objekts fest, an das Sie [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)übergeben`FullyReplicated`. BlazingTextkümmert sich um die Verteilung der Daten auf die Maschinen.

Im überwachten Textklassifizierungsmodus wird eine C5-Instance empfohlen, wenn der Trainingsdatensatz kleiner ist als 2 GB. Verwenden Sie für größere Datensätze eine Instanz mit einer einzigen GPU. BlazingText unterstützt P2-, P3-, G4dn- und G5-Instanzen für Training und Inferenz.

## BlazingText Beispiel-Notizbücher
<a name="blazingtext-sample-notebooks"></a>

Ein Beispielnotizbuch, das den SageMaker BlazingText KI-Algorithmus zur Generierung von Wortvektoren trainiert und einsetzt, finden Sie unter [Word2Vec-Wortdarstellungen lernen mit](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/blazingtext_word2vec_text8/blazingtext_word2vec_text8.html). BlazingText Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instanzen, mit denen Sie das Beispiel in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie den Tab **SageMaker KI-Beispiele**, um eine Liste aller KI-Beispiele zu sehen. SageMaker Die Beispiel-Notebooks für die Themenmodellierung, die Blazing Text verwenden, befinden sich im Abschnitt **Introduction to Amazon algorithms**. Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Use (Verwenden)** und dann **Create copy (Kopie erstellen)**.

# BlazingText Hyperparameter
<a name="blazingtext_hyperparameters"></a>

Wenn Sie einen Trainingsauftrag mit einer `CreateTrainingJob` Anforderung beginnen, geben Sie einen Trainingsalgorithmus an. Sie können auch algorithmusspezifische Hyperparameter als Maps angeben. string-to-string Die Hyperparameter für den BlazingText Algorithmus hängen davon ab, welchen Modus Sie verwenden: Word2Vec (unbeaufsichtigt) und Textklassifikation (überwacht).

## Word2Vec-Hyperparameter
<a name="blazingtext_hyperparameters_word2vec"></a>

In der folgenden Tabelle sind die Hyperparameter für den BlazingText Word2Vec-Trainingsalgorhythmus aufgeführt, der von Amazon AI bereitgestellt wird. SageMaker 


| Name des Parameters | Description | 
| --- | --- | 
| mode |  Die für das Training verwendete Word2vec-Architektur. **Erforderlich** Gültige Werte: `batch_skipgram`, `skipgram` oder `cbow`  | 
| batch\$1size |  Die Größe jedes Stapels, wenn `mode` auf `batch_skipgram` festgelegt ist. Festgelegt auf eine Zahl zwischen 10 und 20. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 11  | 
| buckets |  Die Anzahl von Hash-Buckets für Teilwörter. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 2000000  | 
| epochs |  Die Anzahl von abgeschlossenen Durchläufe durch das Trainingsdaten. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 5  | 
| evaluation |  [Ob das trainierte Modell mit dem -353-Test bewertet wird. WordSimilarity](http://www.gabrilovich.com/resources/data/wordsim353/wordsim353.html) **Optional** Gültige Werte: (Boolescher Wert) `True` oder `False` Standardwert: `True`  | 
| learning\$1rate |  Die für Parameteraktualisierungen verwendete Schrittgröße. **Optional** Gültige Werte: Positive Gleitkommazahl Standardwert: 0.05  | 
| min\$1char |  Die Mindestanzahl der Zeichen für N-Gramm-Zeichen/Teilwörter. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 3  | 
| min\$1count |  Wörter, die weniger als `min_count`-mal angezeigt werden, werden verworfen. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 5  | 
| max\$1char |  Die Höchstanzahl der Zeichen für N-Gramm-Zeichen/Teilwörter. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 6  | 
| negative\$1samples |  Die Anzahl der negativen Beispiele für die Strategie des Austauschs von Negativbeispielen. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 5  | 
| sampling\$1threshold |  Der Schwellenwert für die Häufigkeit von Wörtern. Wörter, die mit höheren Frequenz in den Trainingsdaten erscheinen, werden nach dem Zufallsprinzip heruntergesampelt. **Optional** Gültige Werte: Positive Bruchzahl. Der empfohlene Bereich ist (0, 1e-3] Standardwert: 0.0001  | 
| subwords |  Gibt an, ob Teilworteinbettungen zu lernen sind oder nicht. **Optional** Gültige Werte: (Boolescher Wert) `True` oder `False` Standardwert: `False`  | 
| vector\$1dim |  Die Dimension der Wortvektoren, die der Algorithmus lernt. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 100  | 
| window\$1size |  Die Größe des Kontextfensters. Das Kontextfenster ist die Anzahl der Wörter, die das für das Training verwendete Zielwort umgeben. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 5  | 

## Textklassifizierungs-Hyperparameter
<a name="blazingtext_hyperparameters_text_class"></a>

In der folgenden Tabelle sind die Hyperparameter für den von Amazon SageMaker AI bereitgestellten Schulungsalgorithmus für die Textklassifizierung aufgeführt.

**Anmerkung**  
Auch wenn einige der Parameter in den Textklassifizierungs- und Word2Vec-Modi gängig sind, haben sie möglicherweise je nach Kontext unterschiedliche Bedeutungen.


| Name des Parameters | Description | 
| --- | --- | 
| mode |  Der Trainingsmodus **Erforderlich** Zulässige Werte: `supervised`  | 
| buckets |  Die Anzahl der Hash-Buckets für N-Gramm-Wörter. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 2000000  | 
| early\$1stopping |  Gibt an, ob das Training angehalten wird, wenn sich die Validierungsgenauigkeit nach einer `patience` Reihe von Epochen nicht verbessert. Beachten Sie, dass ein Validierungskanal erforderlich ist, wenn ein Early-Stopping verwendet wird. **Optional** Gültige Werte: (Boolescher Wert) `True` oder `False` Standardwert: `False`  | 
| epochs |  Die maximale Anzahl abgeschlossener Durchläufe durch das Trainingsdaten. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 5  | 
| learning\$1rate |  Die für Parameteraktualisierungen verwendete Schrittgröße. **Optional** Gültige Werte: Positive Gleitkommazahl Standardwert: 0.05  | 
| min\$1count |  Wörter, die weniger als `min_count`-mal angezeigt werden, werden verworfen. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 5  | 
| min\$1epochs |  Die Mindestanzahl der Epochen, die trainiert werden sollen, bevor die Logik zum Early-Stopping aufgerufen wird. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 5  | 
| patience |  Die Anzahl der Epochen, die gewartet werden soll, bevor ein Early-Stopping durchgeführt wird, wenn keine Fortschritte hinsichtlich der festgelegten Validierung erfolgen. Nur verwendet, wenn `early_stopping` `True` ist. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 4  | 
| vector\$1dim |  Die Dimension der Einbettungsebene. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 100  | 
| word\$1ngrams |  Die Anzahl der N-Gramm-Wort-Funktionen, die verwendet werden sollen. **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 2  | 

# Optimieren Sie ein Modell BlazingText
<a name="blazingtext-tuning"></a>

Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik aus den Metriken aus, die der Algorithmus berechnet. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.

Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).

## Vom Algorithmus berechnete Metriken BlazingText
<a name="blazingtext-metrics"></a>

Der BlazingText Word2Vec-Algorithmus (`skipgram``cbow`, und `batch_skipgram` Modi) berichtet während des Trainings über eine einzige Metrik:. `train:mean_rho` Diese Metrik wird für [WS-353 Word Similarity-Datasets](https://aclweb.org/aclwiki/WordSimilarity-353_Test_Collection_(State_of_the_art)) berechnet. Verwenden Sie bei der Optimierung der Hyperparameterwerte für den Word2Vec-Algorithmus diese Metrik als Ziel.

Der BlazingText Textklassifizierungsalgorithmus (`supervised`Modus) berichtet während des Trainings auch über eine einzige Metrik: die. `validation:accuracy` Verwenden Sie bei der Optimierung der Hyperparameterwerte für den Textklassifizierungsalgorithmus diese Metriken als Ziel.


| Metrikname | Description | Optimierungsrichtung | 
| --- | --- | --- | 
| train:mean\$1rho |  Der mittlere rho (Rangkorrelationskoeffizient von Spearman) in [WS-353 Word Similarity-Datasets](http://alfonseca.org/pubs/ws353simrel.tar.gz)  |  Maximieren  | 
| validation:accuracy |  Die Klassifizierungsgenauigkeit im vom Benutzer angegebenen Validierungsdatensatz  |  Maximieren  | 

## Einstellbare Hyperparameter BlazingText
<a name="blazingtext-tunable-hyperparameters"></a>

### Optimierbare Hyperparameters für den Word2Vec-Algorithmus
<a name="blazingtext-tunable-hyperparameters-word2vec"></a>

Optimieren Sie ein Amazon SageMaker AI BlazingText Word2Vec-Modell mit den folgenden Hyperparametern. Die Hyperparameter, die den größten Einfluss auf die objektiven Word2Vec-Metriken haben, sind: `mode`, ` learning_rate`, `window_size`, `vector_dim` und `negative_samples`.


| Name des Parameters | Parametertyp | Empfohlene Bereiche oder Werte | 
| --- | --- | --- | 
| batch\$1size |  `IntegerParameterRange`  |  [8-32]  | 
| epochs |  `IntegerParameterRange`  |  [5-15]  | 
| learning\$1rate |  `ContinuousParameterRange`  |  MinValue: 0,005,: 0,01 MaxValue  | 
| min\$1count |  `IntegerParameterRange`  |  [0-100]  | 
| mode |  `CategoricalParameterRange`  |  [`'batch_skipgram'`, `'skipgram'`, `'cbow'`]  | 
| negative\$1samples |  `IntegerParameterRange`  |  [5-25]  | 
| sampling\$1threshold |  `ContinuousParameterRange`  |  MinValue: 0,0001, MaxValue: 0,001  | 
| vector\$1dim |  `IntegerParameterRange`  |  [32-300]  | 
| window\$1size |  `IntegerParameterRange`  |  [1-10]  | 

### Optimierbare Hyperparameters für den Textklassifizierungsalgorithmus
<a name="blazingtext-tunable-hyperparameters-text_class"></a>

Optimieren Sie ein Amazon SageMaker BlazingText AI-Textklassifizierungsmodell mit den folgenden Hyperparametern.


| Name des Parameters | Parametertyp | Empfohlene Bereiche oder Werte | 
| --- | --- | --- | 
| buckets |  `IntegerParameterRange`  |  [1000000-10000000]  | 
| epochs |  `IntegerParameterRange`  |  [5-15]  | 
| learning\$1rate |  `ContinuousParameterRange`  |  MinValue: 0,005, MaxValue: 0,01  | 
| min\$1count |  `IntegerParameterRange`  |  [0-100]  | 
| vector\$1dim |  `IntegerParameterRange`  |  [32-300]  | 
| word\$1ngrams |  `IntegerParameterRange`  |  [1-3]  | 

# Latent Dirichlet Allocation (LDA)-Algorithmus
<a name="lda"></a>

Der Algorithmus Latent Dirichlet Allocation (LDA) von Amazon SageMaker AI ist ein unüberwachter Lernalgorithmus, der versucht, einen Satz von Beobachtungen als eine Mischung von verschiedenen Kategorien zu beschreiben. LDA wird in erster Linie verwendet, um eine vom Benutzer angegebene Anzahl von Themen in Dokumenten innerhalb eines Textkorpus zu erkennen. Hier ist jede Beobachtung ein Dokument, die Funktionen sind das Vorhandensein (oder Anzahl des Auftretens) einzelner Worte und die Kategorien sind die Themen. Da diese Methode unüberwacht ist, können die Themen nicht im Voraus spezifiziert werden. Zudem ist nicht gewährleistet, dass die Ergebnisse mit der natürlichen menschlichen Kategorisierung dieser Dokumente übereinstimmen. Die Themen werden als Wahrscheinlichkeitsverteilung der Worte, die in den Dokumenten verwendet werden, gelernt. Jedes Dokument wird wiederum als Mischung von Themen beschrieben.

Der genaue Inhalt von zwei verschiedenen Dokumenten mit ähnlichen Themenmischungen kann nicht identisch sein. Jedoch kann davon ausgegangen werden, dass in diesen Dokumenten dieselbe Teilmenge an Wörtern insgesamt häufiger verwendet wird als in Dokumenten, die unterschiedliche Themenmischungen aufweisen. Somit kann LDA diese Wortgruppen erkennen und sie zur Bildung von Themen verwenden. Als ganz einfaches Beispiel kann eine Reihe von Dokumenten dienen, in denen nur die Wörter *essen*, *schlafen*, *spielen*, *miauen* und *bellen* vorkommen. Von LDA werden daraus die folgenden Themen erzeugt:


| **Topic** | *essen* | *schlafen*  | *spielen* | *miauen* | *bellen* | 
| --- | --- | --- | --- | --- | --- | 
| Thema 1  | 0,1  | 0.3  | 0.2  | 0.4  | 0.0  | 
| Thema 2  | 0.2  | 0,1 | 0.4  | 0.0  | 0.3  | 

Sie können daraus rückschließen, dass es in Dokumenten, die Thema 1 zugeordnet sind, um Katzen geht (diese *miauen* und *schlafen*). Dokumente im Thema 2 beschäftigen sich mit Hunden (die gerne *spielen* und auch *bellen*). Diese Themen werden erkannt, auch wenn die Worte Hund und Katze in keinem der Texte vorkommen. 

**Topics**
+ [

## Wahl zwischen Latent Dirichlet Allocation (LDA) und Neural Topic Model (NTM)
](#lda-or-ntm)
+ [

## E/A-Schnittstelle für den LDA-Algorithmus
](#lda-inputoutput)
+ [

## EC2-Instance-Empfehlung für den LDA-Algorithmus
](#lda-instances)
+ [

## LDA-Musternotebooks
](#LDA-sample-notebooks)
+ [

# Funktionsweise von LDA
](lda-how-it-works.md)
+ [

# LDA-Hyperparameter
](lda_hyperparameters.md)
+ [

# Optimieren eines LDA-Modells
](lda-tuning.md)

## Wahl zwischen Latent Dirichlet Allocation (LDA) und Neural Topic Model (NTM)
<a name="lda-or-ntm"></a>

Themenmodelle werden üblicherweise verwendet, um aus einem Korpus Themen zu erzeugen, die (1) die semantische Bedeutung kohärent kapseln und (2) die Dokumente gut beschreiben. Daher zielen Themenmodelle darauf ab, die Verwirrung zu minimieren und die Themenkohärenz zu maximieren. 

Ratlosigkeit ist eine intrinsische Bewertungsmetrik zur Sprachmodellierung, mit der die Umkehrung des geometrischen Mittelwerts der Wahrscheinlichkeit pro Wort in Ihren Testdaten gemessen wird. Ein niedrigerer Wert für Verwirrung weist auf eine bessere Generalisierungsleistung hin. Untersuchungen haben gezeigt, dass die pro Wort berechnete Wahrscheinlichkeit oft nicht dem menschlichen Urteilsvermögen entspricht und völlig unkorreliert sein kann, weshalb Themenkohärenz eingeführt wurde. Jedes abgeleitete Thema aus Ihrem Modell besteht aus Wörtern, und die Themenkohärenz wird anhand der wichtigsten N Wörter für dieses bestimmte Thema aus Ihrem Modell berechnet. Es wird häufig als Durchschnitt oder Median der paarweisen Wortähnlichkeitswerte der Wörter in diesem Thema definiert, z. B. Pointwise Mutual Information (PMI). Ein vielversprechendes Modell generiert kohärente Themen oder Themen mit hohen Punktzahlen für die Themenkohärenz. 

Das Ziel besteht zwar darin, ein Themenmodell zu trainieren, das Verwirrung minimiert und die Themenkohärenz maximiert, aber es gibt oft Kompromisse sowohl bei LDA als auch bei NTM. Jüngste Untersuchungen von Amazon, Dinget et al., 2018 haben gezeigt, dass NTM vielversprechend ist, um eine hohe Themenkohärenz zu erreichen, aber LDA, das mit kollabierten Gibbs-Samples trainiert wurde, erzielt eine bessere Verwirrung. Es gibt einen Kompromiss zwischen Verwirrung und Themenkohärenz. Aus praktischer Sicht in Bezug auf Hardware und Rechenleistung ist die SageMaker NTM-Hardware flexibler als LDA und kann besser skaliert werden, da NTM auf CPU und GPU ausgeführt und über mehrere GPU-Instances parallelisiert werden kann, wohingegen LDA nur Einzel-Instance-CPU-Training unterstützt. 

**Topics**
+ [

## Wahl zwischen Latent Dirichlet Allocation (LDA) und Neural Topic Model (NTM)
](#lda-or-ntm)
+ [

## E/A-Schnittstelle für den LDA-Algorithmus
](#lda-inputoutput)
+ [

## EC2-Instance-Empfehlung für den LDA-Algorithmus
](#lda-instances)
+ [

## LDA-Musternotebooks
](#LDA-sample-notebooks)
+ [

# Funktionsweise von LDA
](lda-how-it-works.md)
+ [

# LDA-Hyperparameter
](lda_hyperparameters.md)
+ [

# Optimieren eines LDA-Modells
](lda-tuning.md)

## E/A-Schnittstelle für den LDA-Algorithmus
<a name="lda-inputoutput"></a>

Für LDA müssen die Daten über den Trainingskanal bereitgestellt werden. Optional wird ein Testkanal unterstützt, der vom finalen Modell bewertet wird. LDA unterstützt die Dateiformate `recordIO-wrapped-protobuf` (mit hoher und geringer Dichte) und `CSV`. Bei `CSV` müssen die Daten eine hohe Dichte sowie eine Dimension gleich *Anzahl der Datensätze \$1 Größe des Vokabulars* aufweisen. Der LDA-Algorithmus kann im Datei- oder Pipe-Modus trainiert werden bei der Verwendung des recordIO-protobuf-Formats, jedoch nur im Dateimodus, wenn das `CSV`-Format verwendet wird.

Für die Inferenz werden die Inhaltstypen `text/csv`, `application/json` und `application/x-recordio-protobuf` unterstützt. Daten mit geringer Dichte können auch für `application/json` und `application/x-recordio-protobuf` übergeben werden. Die LDA-Inferenz gibt – `application/json`oder `application/x-recordio-protobuf`-*Prognosen* zurück, in denen der `topic_mixture`-Vektor für jede einzelne Beobachtung enthalten ist.

Weitere Informationen zu Trainings- und Inferenzformaten finden Sie unter [LDA-Musternotebooks](#LDA-sample-notebooks).

## EC2-Instance-Empfehlung für den LDA-Algorithmus
<a name="lda-instances"></a>

LDA unterstützt derzeit nur Trainings auf Einzel-Instance-CPUs. Für Hosting/Inferenz werden CPU-Instances empfohlen.

## LDA-Musternotebooks
<a name="LDA-sample-notebooks"></a>

Ein Beispiel-Notebook, das zeigt, wie der Algorithmus Latent Dirichlet Allocation von SageMaker AI auf einem Datensatz trainiert wird und wie das trainierte Modell dann eingesetzt wird, um Rückschlüsse auf die Themenmischungen in den Eingabedokumenten zu ziehen, finden Sie im Dokument [Eine Einführung in SageMaker AI LDA](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lda_topic_modeling/LDA-Introduction.html). Anweisungen zum Erstellen von und Zugreifen auf Jupyter-Notebook-Instances, die Sie zum Ausführen des Beispiels in SageMaker AI verwenden können, finden Sie unter [SageMaker Amazon-Notebook-Instanzen](nbi.md). Nachdem Sie eine Notebook-Instance erstellt und geöffnet haben, wählen Sie die Registerkarte **SageMaker-AI-Beispiele**, um eine Liste aller SageMaker-AI-Beispiele anzuzeigen. Die Beispiel-Notebooks zur Themenmodellierung unter Verwendung der NTM-Algorithmen finden Sie im Abschnitt **Einführung in die Amazon-Algorithmen**. Zum Öffnen eines Notebooks klicken Sie auf die Registerkarte **Use (Verwenden)** und wählen Sie **Create copy (Kopie erstellen)** aus.

# Funktionsweise von LDA
<a name="lda-how-it-works"></a>

Amazon SageMaker AI LDA ist ein unüberwachter Lernalgorithmus, der versucht, eine Menge von Beobachtungen als eine Mischung aus verschiedenen Kategorien zu beschreiben. Diese Kategorien sind selbst eine Wahrscheinlichkeitsverteilung der Funktionen. LDA ist ein generatives Wahrscheinlichkeitsmodell – das heißt, LDA versucht, ein Modell für die Verteilung von Aus- und Eingaben auf Basis latenter Variablen zu erzeugen. Im Gegensatz dazu stehen diskriminative Modelle, die versuchen, die Zuordnung von Eingaben zu Ausgaben zu lernen.

Sie können LDA für zahlreiche Aufgaben nutzen – vom Kunden-Clustering auf Basis von Produktkäufen bis zur automatischen Harmonieanalyse von Musikstücken. Größtenteils wird LDA jedoch in Verbindung mit der Themenmodellierung in Textkorpora eingesetzt. Beobachtungen werden als Dokumente bezeichnet. Der Funktionssatz ist das Vokabular. Eine Funktion gibt ein Wort an. Und die resultierenden Kategorien stellen die Themen dar.

**Anmerkung**  
Eine Lemmatisierung führt zu einer erheblich höheren Algorithmusleistung und -genauigkeit. Eine Vorverarbeitung der Eingabetextdaten sollte in Betracht gezogen werden. Weitere Informationen finden Sie unter [Stemming und Lemmatisierung](https://nlp.stanford.edu/IR-book/html/htmledition/stemming-and-lemmatization-1.html).

Ein LDA-Modell wird über zwei Parameter definiert:
+ α – Eine Vorabschätzung der Themenwahrscheinlichkeit (d. h. wie häufig ein einzelnes Thema durchschnittlich in einem bestimmten Dokument auftritt). 
+ β – Eine Sammlung von k-Themen, in der jedem Thema eine Wahrscheinlichkeitsverteilung für das im Dokumentkorpus verwendete Vokabular zugeordnet wird (auch als "Thema-Wort-Verteilung" bezeichnet).

Bei LDA handelt es sich um ein "Bag-of-Words"-Modell, was bedeutet, dass die Reihenfolge der Wörter keine Rolle spielt. LDA ist ein generatives Modell, mit dem jedes Dokument Wort für Wort durch Auswahl einer Themenmischung von θ \$1 Dirichlet(α) generiert wird. 

 Für jedes Wort im Dokument: 
+  Wählen Sie ein Thema z \$1 Multinomial(θ). 
+  Wählen Sie die entsprechende Thema-Wort-Verteilung β\$1z. 
+  Ziehen Sie ein Wort w \$1 Multinomial(β\$1z). 

Bei der Modelltraining besteht das Ziel in der Ermittlung der Parameter α und β; dies maximiert die Wahrscheinlichkeit, dass der Textkorpus vom Modell generiert wird.

Gibbs-Sampling oder Expectation Maximization (EM) sind die gängigsten Methoden zur Einschätzung des LDA-Modells. Der Amazon SageMaker AI LDA verwendet die Tensor-Spektralzerlegung. Diese bietet mehrere Vorteile:
+  **Theoretische Garantie für Ergebnisse**. Bei der EM-Standardmethode wird nur die Konvertierung in lokale Optima garantiert, häufig mit schlechter Qualität. 
+  **Hochgradig parallelisierbar**. Die Arbeit kann sowohl für Training als auch Inferenz trivial über die Eingabedokumente verteilt werden. Auch die EM-Methode und das Gibbs-Sampling lassen sich parallelisieren, jedoch nicht so einfach. 
+  **Schnell**. Die EM-Methode weist zwar niedrige Iterationskosten auf, hat jedoch langsame Konvergenzraten. Auch das Gibbs-Sampling hat langsame Konvergenzraten und erfordert zudem eine hohe Anzahl an Stichproben. 

Allgemein dargestellt folgt der Tensor-Zerlegungsalgorithmus folgendem Prozess:

1.  Das Ziel ist die Berechnung der Spektralzerlegung eines Tensors **V** x **V** x **V**, der die Momente der Dokumente in unserem Textkorpus zusammenfasst. **V** ist die Vokabulargröße (also die Anzahl unterschiedlicher Wörter in allen Dokumenten). Die spektralen Komponenten dieses Tensors sind die LDA-Parameter α und β, welche die allgemeine Wahrscheinlichkeit des Dokumentkorpus maximieren. Da häufig ein sehr umfangreiches und damit großes Vokabular verwendet wird, ist der Tensor **V** x **V** x **V** meist zu groß zum Speichern. 

1.  Stattdessen wird eine Momentenmatrix **V** x **V** eingesetzt, die das zweidimensionale Gegenstück zum Tensor aus Schritt 1 darstellt, um eine Filtermatrix der Dimension **V** x **k** zu bestimmen. Mit dieser Matrix lässt sich die Momentenmatrix **V** x **V** in eine Identitätsmatrix **k** x **k** konvertieren. **k** ist die Anzahl der Themen im Modell. 

1.  Dieselbe Filtermatrix kann zur Ermittlung eines kleineren Tensors **k** x **k** x **k** herangezogen werden. Bei der spektralen Zerlegung hat dieser Tensor Komponenten, die eine einfache Beziehung zu den Komponenten des Tensors **V** x **V** x **V** aufweisen. 

1.  *Alternating Least Squares (alternierende kleinste Quadrate)* wird zur Zerlegung des kleineren Tensors **k** x *k* x **k** verwendet. Damit wird einerseits erheblich weniger Speicher verbraucht und andererseits eine höhere Geschwindigkeit erzielt. Die Parameter α und β lassen sich durch eine "Filteraufhebung" der Ergebnisse in der Spektralzerlegung ermitteln. 

Nach der Ermittlung der LDA-Modellparameter können Sie die Themenmischungen für die einzelnen Dokumente bestimmen. Mithilfe des stochastischen Gradientenverfahrens können Sie die Wahrscheinlichkeitsfunktion maximieren, dass eine bestimmte Themenmischung, die diesen Daten entspricht, beobachtet wird.

Die Themenqualität lässt sich verbessern, indem Sie die Themenanzahl in dem Training erhöhen und dann Ergebnisse mit schlechter Qualität herausfiltern. In SageMaker AI LDA wird das bei der LDA-Methode bereits automatisch ausgeführt: Es werden 25 % mehr Themen berechnet und nur solche mit den höchsten zugeordneten Dirichlet-Prioren zurückgegeben. Zur weiteren Themenfilterung und -analyse können Sie die Themenzahl erhöhen und das resultierende LDA-Modell wie folgt ändern:

```
> import mxnet as mx
> alpha, beta = mx.ndarray.load(‘model.tar.gz’)
> # modify alpha and beta
> mx.nd.save(‘new_model.tar.gz’, [new_alpha, new_beta])
> # upload to S3 and create new SageMaker model using the console
```

Weitere Informationen über Algorithmen für LDA und die SageMaker-AI-Implementierung finden Sie im Folgenden:
+ Animashree Anandkumar, Rong Ge, Daniel Hsu, Sham M Kakade und Matus Telgarsky. *Tensor Decompositions for Learning Latent Variable Models*, Journal of Machine Learning Research, 15:2773 bis 2832, 2014.
+  David M Blei, Andrew Y Ng und Michael I Jordan. *Latent Dirichlet Allocation*. Journal of Machine Learning Research, 3(Jan):993 bis 1022, 2003.
+  Thomas L Griffiths und Mark Steyvers. *Finding Scientific Topics*. Proceedings of the National Academy of Sciences, 101(suppl 1):5228 bis 5235, 2004. 
+  Tamara G Kolda und Brett W Bader. *Tensor Decompositions and Applications*. SIAM Review, 51(3):455 bis 500, 2009. 

# LDA-Hyperparameter
<a name="lda_hyperparameters"></a>

In der Anforderung `CreateTrainingJob` geben Sie den Trainingsalgorithmus an. Sie können außerdem algorithmusspezifische Hyperparameter als Zeichenfolge-zu-Zeichenfolge-Zuweisungen angeben. In der folgenden Tabelle sind die Hyperparameter für den von Amazon SageMaker AI bereitgestellten LDA-Trainingsalgorithmus aufgeführt. Weitere Informationen finden Sie unter [Funktionsweise von LDA](lda-how-it-works.md).


| Name des Parameters | Beschreibung | 
| --- | --- | 
| num\$1topics |  Die Anzahl der Themen, die per LDA innerhalb der Daten ermittelt werden sollen. **Erforderlich** Gültige Werte: positive Ganzzahl  | 
| feature\$1dim |  Die Vokabulargröße des Eingabedokumentkorpus. **Erforderlich** Gültige Werte: positive Ganzzahl  | 
| mini\$1batch\$1size |  Die Gesamtanzahl der Dokumente im Eingabedokumentkorpus. **Erforderlich** Gültige Werte: positive Ganzzahl  | 
| alpha0 |  Erstschätzung des Konzentrationsparameters: die Summe der Dirichlet-Priorelemente. Geringe Werte führen eher zu kleinen Themenmischungen, bei höheren Werten (über 1.0) werden einheitlichere Mischungen generiert.  **Optional** Gültige Werte: Positive Gleitkommazahl Standardwert: 1.0  | 
| max\$1restarts |  Die Anzahl der Neustarts, die während der ALS (Alternating Least Squares)-Spektralzerlegungsphase des Algorithmus ausgeführt werden. Damit lassen sich lokale Minima besserer Qualität ermitteln, jedoch auf Kosten weiterer Berechnungen; und im Allgemeinen sollte hier keine Anpassung erfolgen.  **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 10  | 
| max\$1iterations |  Die maximale Anzahl der Iterationen, die im Rahmen der ALS-Phase des Algorithmus ausgeführt werden sollen. Damit lassen sich Minima besserer Qualität ermitteln, jedoch auf Kosten weiterer Berechnungen; und im Allgemeinen sollte hier keine Anpassung erfolgen.  **Optional** Gültige Werte: Positive Ganzzahl Standardwert: 1000  | 
| tol |  Die Zielfehlertoleranz für die ALS-Phase des Algorithmus. Damit lassen sich Minima besserer Qualität ermitteln, jedoch auf Kosten weiterer Berechnungen; und im Allgemeinen sollte hier keine Anpassung erfolgen.  **Optional** Gültige Werte: Positive Gleitkommazahl Standardwert: 1e-8  | 

# Optimieren eines LDA-Modells
<a name="lda-tuning"></a>

Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik aus den Metriken aus, die der Algorithmus berechnet. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.

LDA ist ein unüberwachter Themenmodellierungsalgorithmus, der versucht, eine Reihe von Beobachtungen (Dokumente) als Mischung unterschiedlicher Kategorien (Themen) zu beschreiben. Die "per-word log-likelihood" (PWLL)-Metrik misst die Wahrscheinlichkeit, dass eine gelernte Reihe von Themen (ein LDA-Modell) ein Testdokument-Datensatz genau beschreibt. Größere PWLL-Werte weisen darauf hin, dass die Testdaten mit größerer Wahrscheinlichkeit vom LDA-Modell beschrieben werden.

Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).

## Vom LDA-Algorithmus berechnete Metriken
<a name="lda-metrics"></a>

Der LDA-Algorithmus meldet eine einzelnen Metrik während des Trainings: `test:pwll`. Wählen Sie beim Optimieren eines Modells diese Metrik als objektive Metrik aus.


| Metrikname | Beschreibung | Optimierungsrichtung | 
| --- | --- | --- | 
| test:pwll | Per-word log-likelihood des Testdatensatzes. Die Wahrscheinlichkeit, dass der Testdatensatz vom gelernten LDA-Modell genau beschrieben wird. | Maximieren | 

## Optimierbare LDA-Hyperparameter
<a name="lda-tunable-hyperparameters"></a>

Sie können die folgenden Hyperparameter für den LDA-Algorithmus optimieren. Beide Hyperparameter, `alpha0` und `num_topics`, können die objektive LDA-Metrik (`test:pwll`) beeinflussen. Wenn Sie die optimalen Werte für diese Hyperparameter, die die per-word log-likelihood maximieren und ein präzises LDA-Modell erzeugen, noch nicht kennen, kann die automatische Modelloptimierung weiterhelfen.


| Name des Parameters | Parametertyp | Empfohlene Bereiche | 
| --- | --- | --- | 
| alpha0 | ContinuousParameterRanges | MinValue: 0.1, MaxValue: 10 | 
| num\$1topics | IntegerParameterRanges | MinValue: 1, MaxValue: 150 | 

# Algorithmus für neuronale Themenmodellierung (NTM)
<a name="ntm"></a>

Amazon SageMaker AI NTM ist ein Algorithmus für unbeaufsichtigtes Lernen, der verwendet wird, um einen Korpus von Dokumenten in *Themen* zu organisieren, die Wortgruppierungen auf der Grundlage ihrer statistischen Verteilung enthalten. Dokumente mit häufigen Vorkommen von Wörtern wie "Fahrrad", "Auto", "Zug", "Laufleistung" und "Geschwindigkeit" haben wahrscheinlich das gemeinsame Thema "Transport". Die Themenmodellierung kann verwendet werden, um Dokumente basierend auf den erkannten Themen zu klassifizieren oder zusammenzufassen oder um Informationen abzurufen oder Inhalte basierend auf Themengemeinsamkeiten zu empfehlen. Die Themen aus Dokumenten, die NTM lernt, werden als *latente Darstellung* bezeichnet, da die Themen aus den beobachteten Wortverteilungen im Datensatz abgeleitet werden. Die Semantik der Themen wird in der Regel abgeleitet, indem die enthaltenen Wörter mit dem höchsten Rang untersucht werden. Da die Methode unüberwacht ist, wird nur die Anzahl der Themen, jedoch nicht die Themen selbst vorab definiert. Darüber hinaus kann nicht garantiert werden, dass die Kategorisierung der Themen so aussieht, wie sie ein Mensch vornehmen würde.

Themenmodellierung bietet eine Möglichkeit zur Visualisierung der Inhalte eines großen Dokumentkorpus im Hinblick auf die gelernten Themen. Für das Thema relevante Dokumente können indiziert werden oder man kann auf der Basis weicher Themenkennzeichnungen nach ihnen suchen. Die latenten Darstellungen der Dokumente können auch verwendet werden, um ähnliche Dokumente im Themenraum zu finden. Sie können die latenten Darstellungen von Dokumenten, die das Themenmodell lernt, auch als Eingabe für einen anderen überwachten Algorithmus verwenden, wie z. B. einen Dokumenten-Classifier. Da latente Darstellungen von Dokumenten die Semantik der zugrunde liegenden Dokumente erfassen sollen, ist davon auszugehen, dass Algorithmen, die teilweise auf diesen Darstellungen basieren, bessere Ergebnisse liefern als Algorithmen, denen nur lexikalische Merkmale zugrunde liegen.

Sie können zwar sowohl den Amazon SageMaker AI NTM- als auch den LDA-Algorithmus für die Themenmodellierung verwenden, es handelt sich jedoch um unterschiedliche Algorithmen, von denen erwartet werden kann, dass sie mit denselben Eingabedaten unterschiedliche Ergebnisse liefern.

Weitere Informationen zu den mathematischen Hintergründen von NTM finden Sie unter [Neural Variational Inference for Text Processing](https://arxiv.org/pdf/1511.06038.pdf).

**Topics**
+ [

## E/A-Schnittstelle für den NTM-Algorithmus
](#NTM-inputoutput)
+ [

## EC2-Instance-Empfehlung für den NTM-Algorithmus
](#NTM-instances)
+ [

## NTM-Beispiel-Notebooks
](#NTM-sample-notebooks)
+ [

# NTM-Hyperparameter
](ntm_hyperparameters.md)
+ [

# Optimieren eines NTM-Modells
](ntm-tuning.md)
+ [

# NTM-Antwortformate
](ntm-in-formats.md)

## E/A-Schnittstelle für den NTM-Algorithmus
<a name="NTM-inputoutput"></a>

Das Amazon SageMaker AI Neural Topic Model unterstützt vier Datenkanäle: Train, Validation, Test und Auxiliary. Die Validierungs-, Test- und Zusatzdatenkanäle sind optional. Wenn Sie einen der folgenden optionalen Kanäle angeben, legen Sie den Wert des `S3DataDistributionType`-Parameters für sie auf `FullyReplicated` fest. Wenn Sie die Validierungsdaten bereitstellen, wird der Datenverlust für jede Epoche protokolliert und das Modell stoppt das Training, sobald es erkennt, dass der Validierungsverlust sich nicht verbessert. Wenn Sie keine Validierungsdaten bereitstellen, stoppt der Algorithmus früh auf Basis der Trainingsdaten, dies kann jedoch weniger effizient sein. Wenn Sie die Testdaten bereitstellen, erfasst der Algorithmus den Testverlust des letzten Modells. 

Die Trainings-, Validierungs- und Testdatenkanäle für NTM unterstützen sowohl `recordIO-wrapped-protobuf` (mit hoher und niedriger Dichte) als auch `CSV` als Dateiformate. Wird das `CSV`-Format verwendet, muss jede Zeile dicht mit Nullzählern für Wörter dargestellt werden, die im entsprechenden Dokument nicht vorhanden sind und folgende Dimension haben: (Anzahl Datensätze) \$1 (Vokabulargröße). Sie können entweder den Datei- oder den Pipe-Modus verwenden, um Modelle mit Daten, die als `recordIO-wrapped-protobuf` oder `CSV` formatiert sind, zu trainieren. Der Zusatzkanal wird verwendet, um eine Textdatei mit Vokabular bereitzustellen. Durch die Bereitstellung der Vokabeldatei können Benutzer anstelle der Ganzzahl die wichtigsten Wörter für jedes der Themen im Protokoll sehen IDs. Wenn die Vokabulardatei vorliegt, kann NTM außerdem die Word Embedding Topic Coherence (WETC)-Bewertungen berechnen. Diese neue Metrik wird im Protokoll zur effektiven Erfassung von Ähnlichkeiten zwischen den wichtigsten Wörtern in jedem Thema angezeigt. Der `ContentType` Hilfskanal ist so angeordnet`text/plain`, dass jede Zeile ein einzelnes Wort enthält, und zwar in der Reihenfolge, die der in den Daten IDs angegebenen Ganzzahl entspricht. Die Vokabulardatei muss den Namen `vocab.txt` tragen. Derzeit wird nur UTF-8-Codierung unterstützt. 

Für die Inferenz werden die Inhaltstypen `text/csv`, `application/json`, `application/jsonlines` und `application/x-recordio-protobuf` unterstützt. Daten mit geringer Dichte können auch für `application/json` und `application/x-recordio-protobuf` übergeben werden. Die NTM-Inferenz gibt – `application/json`oder `application/x-recordio-protobuf`-*Prognosen* zurück, in denen der `topic_weights`-Vektor für jede einzelne Beobachtung enthalten ist.

Weitere Informationen zur Verwendung des Aux-Kanals und zu den WEC-Scores finden Sie im [Blogbeitrag](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-neural-topic-model-now-supports-auxiliary-vocabulary-channel-new-topic-evaluation-metrics-and-training-subsampling/). Weitere Informationen zum Berechnen der WETC-Bewertung finden Sie unter [Coherence-Aware Neural Topic Modeling](https://arxiv.org/pdf/1809.02687.pdf). Wir haben das in diesem paper beschriebene paarweise WETC für das Amazon SageMaker AI Neural Topic Model verwendet.

Weitere Informationen über die Eingabe- und Ausgabedateiformate finden Sie unter [NTM-Antwortformate](ntm-in-formats.md) für Inferenz und unter [NTM-Beispiel-Notebooks](#NTM-sample-notebooks).

## EC2-Instance-Empfehlung für den NTM-Algorithmus
<a name="NTM-instances"></a>

NTM-Trainings unterstützen sowohl GPU- und CPU-Instance-Typen. Wir empfehlen GPU-Instances, aber bei bestimmten Arbeitslasten können CPU-Instances die Trainingskosten senken. CPU-Instances sollten für Inferenz ausreichend sein. NTM-Training unterstützt die GPU-Instancefamilien P2, P3, G4dn und G5 für Training und Inferenz.

## NTM-Beispiel-Notebooks
<a name="NTM-sample-notebooks"></a>

Ein Beispielnotizbuch, das den SageMaker KI-NTM-Algorithmus verwendet, um Themen in Dokumenten aus einer synthetischen Datenquelle aufzudecken, deren Themenverteilungen bekannt sind, finden Sie in der [Einführung](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/ntm_synthetic/ntm_synthetic.html) in die grundlegenden Funktionen von NTM. Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instanzen, mit denen Sie das Beispiel in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie den Tab **SageMaker KI-Beispiele** aus, um eine Liste aller KI-Beispiele zu sehen. SageMaker Die Beispiel-Notebooks zur Themenmodellierung unter Verwendung der NTM-Algorithmen finden Sie im Abschnitt **Einführung in die Amazon-Algorithmen**. Zum Öffnen eines Notebooks klicken Sie auf die Registerkarte **Use (Verwenden)** und wählen Sie **Create copy (Kopie erstellen)** aus.

# NTM-Hyperparameter
<a name="ntm_hyperparameters"></a>

In der folgenden Tabelle sind die Hyperparameter aufgeführt, die Sie für den Amazon SageMaker AI Neural Topic Model (NTM) -Algorithmus festlegen können.


| Name des Parameters | Description | 
| --- | --- | 
|  `feature_dim`  |  Die Vokabulargröße des Datensatzes. **Erforderlich** Gültige Werte: Positive Ganzzahl (min: 1, max: 1000000)  | 
| num\$1topics |  Die Anzahl der erforderlichen Themen **Erforderlich** Gültige Werte: Positive Ganzzahl (min: 2, max: 1000)  | 
| batch\$1norm |  Gibt an, ob die Batch-Normalisierung während des Trainings angewendet werden soll. **Optional** Gültige Werte: *true* oder *false* Standardwert: *false*  | 
| clip\$1gradient |  Die maximale Größenordnung für jede Gradienten-Komponente. **Optional** Gültige Werte: Gleitkommazahl. (min: 1e-3) Standardwert: Infinity  | 
| encoder\$1layers |  Die Anzahl der Ebenen im Encoder und die Ausgabegröße der einzelnen Ebenen. Wenn der Algorithmus auf *auto* gesetzt ist, verwendet er jeweils zwei Ebenen der Größe 3 x `num_topics` und 2 x `num_topics`.  **Optional** Gültige Werte: durch Kommas getrennte Liste positiver Ganzzahlen oder *auto* Standardwert: *auto*  | 
| encoder\$1layers\$1activation |  Die Aktivierungsfunktion zur Verwendung in Encoder-Ebenen. **Optional** Zulässige Werte:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/ntm_hyperparameters.html) Standardwert: `sigmoid`  | 
| epochs |  Die maximale Anzahl von Durchläufen der Trainingsdaten. **Optional** Gültige Werte: Positive Ganzzahl (min: 1) Standardwert: 50  | 
| learning\$1rate |  Die Lernrate für den Optimierer. **Optional** Gültige Werte: Gleitkommazahl. (min: 1e-6, max: 1,0) Standardwert: 0.001  | 
| mini\$1batch\$1size |  Die Anzahl der Beispiele in jedem Mini-Stapel. **Optional** Gültige Werte: Positive Ganzzahl (min: 1, max: 10000) Standardwert: 256  | 
| num\$1patience\$1epochs |  Die Anzahl der aufeinanderfolgenden Epochen, für die das Kriterium der frühzeitigen Beendigung ausgewertet wird. Die frühzeitige Beendigung wird ausgelöst, wenn die Änderung in der Verlustfunktion unter den angegebenen `tolerance`-Wert innerhalb der letzten `num_patience_epochs` Epochen fällt. Wenn Sie ein frühzeitiges Beenden unterbinden möchten, setzen Sie `num_patience_epochs` auf einen Wert größer als `epochs`. **Optional** Gültige Werte: Positive Ganzzahl (min: 1) Standardwert: 3  | 
| optimizer |  Der Optimierer für Trainings. **Optional** Zulässige Werte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/ntm_hyperparameters.html) Standardwert: `adadelta`  | 
| rescale\$1gradient |  Der Faktor zur Gradienten-Neuskalierung. **Optional** Gültige Werte: Gleitkommazahl. (min: 1e-3, max: 1,0) Standardwert: 1.0  | 
| sub\$1sample |  Der Bruchteil der Trainingsdaten, die für Trainings pro Epoche gesampelt werden sollen. **Optional** Gültige Werte: Gleitkommazahl (min: 0,0, max: 1,0) Standardwert: 1.0  | 
| tolerance |  Die maximale relative Änderung in der Verlustfunktion. Die frühzeitige Beendigung wird ausgelöst, wenn die Änderung in der Verlustfunktion innerhalb der letzten `num_patience_epochs` Epochen unter diesen Wert fällt. **Optional** Gültige Werte: Gleitkommazahl. (min: 1e-6, max: 0.1) Standardwert: 0.001  | 
| weight\$1decay |   Der Weight-Decay-Koeffizient. Fügt L2-Regularisierung hinzu. **Optional** Gültige Werte: Gleitkommazahl (min: 0,0, max: 1,0) Standardwert: 0.0  | 

# Optimieren eines NTM-Modells
<a name="ntm-tuning"></a>

Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik aus den Metriken aus, die der Algorithmus berechnet. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.

Amazon SageMaker AI NTM ist ein Algorithmus für unbeaufsichtigtes Lernen, der latente Repräsentationen großer Sammlungen diskreter Daten, wie z. B. eines Korpus von Dokumenten, lernt. Latente Darstellungen verwenden abgeleitete Variablen, die nicht direkt gemessen werden, um die Beobachtungen in einem Datensatz zu modellieren. Mithilfe der automatischen Modelloptimierung im NTM finden Sie das Modell, das den Verlust von Trainings- oder Validierungsdaten minimiert. Mit dem *Trainingsverlust* wird gemessen, wie gut das Modell zu den Trainingsdaten passt. Anhand des *Validierungsverlusts* wird gemessen, wie gut das Modell im Hinblick auf Daten verallgemeinern kann, die nicht Bestandteil des Trainings sind. Ein niedriger Trainingsverlust gibt an, dass ein Modell für das Trainingsdaten gut passt. Geringe Validierungsverluste zeigen an, dass ein Modell die Trainingsdaten nicht übermäßig angepasst hat und daher in der Lage sein sollte, Dokumente erfolgreich zu modellieren, für die es nicht trainiert wurde. Normalerweise ist es am besten, wenn beide Verluste klein sind. Ein zu starkes Minimieren des Trainingsverlusts kann jedoch zur Überanpassung führen und den Validierungsverlust erhöhen. Dies würde die Allgemeingültigkeit des Modells reduzieren. 

Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).

## Vom NTM-Algorithmus berechnete Metriken
<a name="ntm-metrics"></a>

Der NTM-Algorithmus meldet eine einzelne Metrik, die während des Trainings berechnet wird: `validation:total_loss`. Der gesamte Verlust ist die Summe aus Rekonstruktionsverlust und Kullback-Leibler-Divergenz. Wenn Sie die Hyperparameterwerte optimieren, wählen Sie diese Metrik als objektive Metrik aus.


| Metrikname | Description | Optimierungsrichtung | 
| --- | --- | --- | 
| validation:total\$1loss |  Gesamter Verlust im Validierungsdatensatz  |  Minimieren  | 

## Optimierbare NTM-Hyperparameter
<a name="ntm-tunable-hyperparameters"></a>

Sie können die folgenden Hyperparameter für den NTM-Algorithmus optimieren. Mit niedrigen – `mini_batch_size`und kleinen `learning_rate`-Werten entstehen geringere Validierungsverluste, allerdings kann das Training länger dauern. Niedrige Validierungsverluste produzieren nicht unbedingt kohärente Themen nach Auslegung durch Menschen. Die Wirkung anderer Hyperparameter auf Trainings und Validierungsverlust kann von Datensatz zu Datensatz variieren. Informationen dazu, welche Werte kompatibel sind, finden Sie unter [NTM-Hyperparameter](ntm_hyperparameters.md).


| Name des Parameters | Parametertyp | Empfohlene Bereiche | 
| --- | --- | --- | 
| encoder\$1layers\$1activation |  CategoricalParameterRanges  |  ['sigmoid', 'tanh', 'relu']  | 
| learning\$1rate |  ContinuousParameterRange  |  MinValue: 1e-4,: 0,1 MaxValue  | 
| mini\$1batch\$1size |  IntegerParameterRanges  |  MinValue: 16, :2048 MaxValue  | 
| optimizer |  CategoricalParameterRanges  |  ['sgd', 'adam', 'adadelta']  | 
| rescale\$1gradient |  ContinuousParameterRange  |  MinValue: 0,1,: 1,0 MaxValue  | 
| weight\$1decay |  ContinuousParameterRange  |  MinValue: 0,0, MaxValue: 1,0  | 

# NTM-Antwortformate
<a name="ntm-in-formats"></a>

Alle integrierten Algorithmen von Amazon SageMaker AI halten sich an das gemeinsame Eingabe-Inferenzformat, das unter [Common Data Formats — Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) beschrieben ist. Dieses Thema enthält eine Liste der verfügbaren Ausgabeformate für den SageMaker AI NTM-Algorithmus.

## JSON-Antwortformat
<a name="ntm-json"></a>

```
{
    "predictions":    [
        {"topic_weights": [0.02, 0.1, 0,...]},
        {"topic_weights": [0.25, 0.067, 0,...]}
    ]
}
```

## JSONLINES-Antwortformat
<a name="ntm-jsonlines"></a>

```
{"topic_weights": [0.02, 0.1, 0,...]}
{"topic_weights": [0.25, 0.067, 0,...]}
```

## RECORDIO-Antwortformat
<a name="ntm-recordio"></a>

```
[
    Record = {
        features = {},
        label = {
            'topic_weights': {
                keys: [],
                values: [0.25, 0.067, 0, ...]  # float32
            }
        }
    },
    Record = {
        features = {},
        label = {
            'topic_weights': {
                keys: [],
                values: [0.25, 0.067, 0, ...]  # float32
            }
        }
    }  
]
```

# Object2Vec-Algorithmus
<a name="object2vec"></a>

Der Amazon SageMaker AI Object2Vec-Algorithmus ist ein Allzweck-Algorithmus zur neuronalen Einbettung, der in hohem Maße anpassbar ist. Er kann dichte Einbettungen mit geringer Dimensionalität hochdimensionaler Objekte lernen. Die Einbettungen werden so gelernt, dass die Semantik der Beziehung zwischen Paaren von Objekten im ursprünglichen Raum im Einbettungsraum beibehalten werden. Sie können die gelernten Einbettungen z. B. zum effizienten Berechnen der nächsten Nachbarn von Objekten und zum Visualisieren natürlicher Cluster verwandter Objekte im Raum mit geringer Dimensionalität verwenden. Außerdem können Sie die Einbettungen als Funktionen der entsprechende Objekten in nachgelagerten überwachten Aufgaben, wie z. B. Klassifizierung oder Regression, einsetzen. 

Object2Vec verallgemeinert die bekannte Word2Vec-Einbettungstechnik für Wörter, die in der KI optimiert ist. SageMaker [BlazingText Algorithmus](blazingtext.md) Einen Blogbeitrag, in dem beschrieben wird, wie Object2Vec auf einige praktische Anwendungsfälle angewendet werden kann, finden Sie unter [Einführung in Amazon SageMaker ](https://aws.amazon.com/blogs/machine-learning/introduction-to-amazon-sagemaker-object2vec/) AI Object2Vec. 

**Topics**
+ [

## E/A-Schnittstelle für den Object2Vec-Algorithmus
](#object2vec-inputoutput)
+ [

## EC2-Instance-Empfehlung für den Object2Vec-Algorithmus
](#object2vec--instances)
+ [

## Object2Vec-Beispiel-Notebooks
](#object2vec-sample-notebooks)
+ [

# So funktioniert der Object2Vec-Algorithmus
](object2vec-howitworks.md)
+ [

# Object2Vec-Hyperparameter
](object2vec-hyperparameters.md)
+ [

# Optimieren eines Object2Vec-Modells
](object2vec-tuning.md)
+ [

# Datenformate für das Object2Vec-Training
](object2vec-training-formats.md)
+ [

# Datenformate für Object2Vec-Inferenzen
](object2vec-inference-formats.md)
+ [

# Encoder-Einbettungen für Object2Vec
](object2vec-encoder-embeddings.md)

## E/A-Schnittstelle für den Object2Vec-Algorithmus
<a name="object2vec-inputoutput"></a>

Sie können den Object2Vec-Algorithmus für viele Eingabedatentypen nutzen, z. B. folgende:


| Eingabedatentyp | Beispiel | 
| --- | --- | 
|  Satz-Satz Paare  | „Ein Fußballspiel, bei dem mehrere Männer spielen.“ und „Manche Männer treiben Sport.“ | 
|  Bezeichnungen-Sequenz-Paare  | Die Genre-Tags des Films "Titanic", z. B. "Romanze" und "Drama", und dessen Kurzbeschreibung: "Bei Titanic von James Cameron handelt es sich um eine epische, actionreiche Romanze vor dem Hintergrund der verhängnisvollen Jungfernfahrt der R.M.S. Titanic. Die Titanic war das luxuriöseste Kreuzfahrtschriff seiner Zeit, ein wahres Traumschiff, das in den frühen Morgenstunden des 15. April 1912 1 500 Menschen in den eiskalten Gewässern des Nordatlantik in den Tod riss." | 
|  Kunde-Kunde-Paare  |  Die Kunden-ID von Jane und die Kunden-ID von Jackie.  | 
|  Produkt-Produkt-Paare  |  Die Produkt-ID des Fußballs und Produkt-ID des Basketballs.  | 
|  Artikelrezension-Benutzerartikel-Paare  |  Eine Benutzer-ID und die gekauften Artikel, z. B. Apfel, Birne und Orange.  | 

Zum Umwandeln der Eingabedaten in die unterstützten Formate müssen Sie sie vorverarbeiten. Derzeit unterstützt Object2Vec nativ zwei Arten von Eingaben: 
+ Ein diskretes Token, das als Liste einer einzigen `integer-id` dargestellt wird. Beispiel, `[10]`.
+ Sequenzen diskreter Token, die als Liste von `integer-ids` dargestellt werden. Beispiel, `[0,12,10,13]`.

Das Objekt in jedem Paar kann asymmetrisch sein. Beispiel: Die Paare können (Token, Sequenz) oder (Token, Token) oder (Sequenz, Sequenz) sein. Für Tokeneingaben unterstützt der Algorithmus einfache Einbettungen als kompatible Encoder. Für Sequenzen von Tokenvektoren unterstützt der Algorithmus die folgenden Encoder:
+  Einbettungen mit Durchschnitts-Pooling
+  Hierarchische neuronale Faltungsnetzwerke (), CNNs
+  Mehrschichtiges bidirektionales Langzeitgedächtnis (Bi) LSTMs 

Die Eingabebezeichnung für jedes Paar kann eine der folgenden sein:
+ Eine kategorische Bezeichnung, die die Beziehung zwischen den Objekten im Paar ausdrückt 
+ Eine Punktzahl, die die Stärke der Ähnlichkeit zwischen den beiden Objekten ausdrückt 

Für kategorische Bezeichnungen, die in der Klassifizierung verwendet werden, unterstützt der Algorithmus die Kreuz-Entropie Verlustfunktion. Für Bewertungen/ergebnisbasierte Bezeichnungen, die in der Regression genutzt werden, unterstützt der Algorithmus die MSE-Verlustfunktion (Mean Squared Error, mittlerer quadratischer Fehler). Geben Sie diese Verlustfunktionen mit dem Hyperparameter `output_layer` an, wenn Sie den Modelltrainingsauftrag erstellen.

## EC2-Instance-Empfehlung für den Object2Vec-Algorithmus
<a name="object2vec--instances"></a>

Welchen Elastic Compute Cloud (Amazon EC2)-Instance-Typ Sie verwenden, hängt davon ab, ob Sie Inferenzen trainieren oder ausführen. 

Wenn Sie ein Modell mit dem Object2Vec-Algorithmus auf einer CPU trainieren, starten Sie mit einer ml.m5.2xlarge-Instance. Bei Trainings auf einer GPU-Instance starten Sie mit einer ml.p2.xlarge-Instance. Wenn das Training auf dieser Instance zu lange dauert, können Sie eine größere Instance verwenden. Derzeit können Sie den Object2Vec-Algorithmus nur auf einer einzelnen Maschine trainieren. Es bietet jedoch Unterstützung für mehrere. GPUs Object2Vec unterstützt die GPU-Instance-Familien P2, P3, G4dn und G5 für Training und Inferenz.

Für Inferenzen mit dem trainierten Object2Vec-Modell, das über ein tiefes neuronalen Netz verfügt, empfehlen wir die Verwendung der ml.p3.2xlarge-GPU-Instance. Aufgrund der GPU-Speicherknappheit kann die Umgebungsvariable `INFERENCE_PREFERRED_MODE` zur Optimierung angegeben werden, ob das Inferenznetzwerk [GPU-Optimierung: Klassifizierung oder Regression](object2vec-inference-formats.md#object2vec-inference-gpu-optimize-classification) oder [GPU-Optimierung: Encoder-Einbettungen](object2vec-encoder-embeddings.md#object2vec-inference-gpu-optimize-encoder-embeddings) in die GPU geladen wird.

## Object2Vec-Beispiel-Notebooks
<a name="object2vec-sample-notebooks"></a>
+ [Verwenden von Object2Vec zum Codieren von Sätzen in Einbettungen mit fester Länge](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/object2vec_sentence_similarity/object2vec_sentence_similarity.html)

# So funktioniert der Object2Vec-Algorithmus
<a name="object2vec-howitworks"></a>

Wenn Sie den Amazon SageMaker AI Object2Vec-Algorithmus verwenden, folgen Sie dem Standard-Workflow: Verarbeiten Sie die Daten, trainieren das Modell und ziehen Sie Schlussfolgerungen. 

**Topics**
+ [

## Schritt 1: Verarbeiten von Daten
](#object2vec-step-1-data-preprocessing)
+ [

## Schritt 2: Schulen eines Modells
](#object2vec-step-2-training-model)
+ [

## Schritt 3: Erstellen von Inferenzen
](#object2vec-step-3-inference)

## Schritt 1: Verarbeiten von Daten
<a name="object2vec-step-1-data-preprocessing"></a>

Während der Vorverarbeitung konvertieren Sie die Daten in das Textdateiformat [JSON Lines](http://jsonlines.org/), wie unter [Datenformate für das Object2Vec-Training](object2vec-training-formats.md) angegeben. Um bei dem Training höchste Genauigkeit zu erhalten, mischen Sie die Daten zufällig, bevor Sie sie an das Modell übertragen. Wie zufällige Permutationen generiert werden, hängt von der Sprache ab. Für Python können Sie `np.random.shuffle` und für Unix `shuf` verwenden.

## Schritt 2: Schulen eines Modells
<a name="object2vec-step-2-training-model"></a>

Der SageMaker AI Object2Vec-Algorithmus besteht aus den folgenden Hauptkomponenten:
+ **Zwei Eingabekanäle** – Die zwei Eingabekanäle akzeptieren ein Objektpaar des gleichen oder verschiedener Typen als Eingaben und übergeben sie an unabhängige und anpassbare Encoder.
+ **Zwei Encoder** – Die beiden Encoder, enc0 und enc1, konvertieren jedes Objekt in einen eingebetteten Vektor mit fester Länge. Die codierten Einbettungen der Objekte im Paar werden dann in einen Vergleichsoperator übergeben.
+ **Ein Vergleichsoperator** – Der Vergleichsoperator vergleicht die Einbettungen auf unterschiedliche Weise und gibt Ergebnisse aus, die die Stärke der Beziehung zwischen den gepaarten Objekten angeben. Im Ausgabeergebnis für ein Satzpaar. Beispielsweise gibt "1" eine starke Beziehung zwischen einem Satzpaar und "0" eine schwache Beziehung an. 

Zum Zeitpunkt des Trainings akzeptiert der Algorithmus Paare von Objekten und deren Beziehungsbezeichnungen oder Ergebnisse als Eingaben. Die Objekte in jedem Paar können wie zuvor beschrieben unterschiedlichen Typs sein. Wenn die Eingaben für beide Encoder aus den gleichen Einheiten auf Token-Ebene bestehen, können Sie ein gemeinsames Token verwenden und die Ebene durch Festlegen des Hyperparameters `tied_token_embedding_weight` auf `True` einbetten, wenn Sie den Trainingsauftrag erstellen. Dies ist z. B. möglich, wenn Sie Sätze vergleichen, die beide über Einheiten auf Wort-Token-Ebene verfügen. Um negative Stichproben zu einer festgelegten Rate zu generieren, legen Sie den Hyperparameter `negative_sampling_rate` auf das gewünschte Verhältnis von positiven zu negativen Stichproben fest. Dieser Hyperparameter beschleunigt das Lernen bezüglich der Unterscheidung zwischen den positiven Stichproben, die in den Trainingsdaten beobachtet wurden, und den negativen Stichproben, die wahrscheinlich nicht beobachtet werden. 

Objektpaare werden durch unabhängige, anpassbare Encoder übergeben, die mit den Eingabetypen von entsprechenden Objekten kompatibel sind. Die Encoder konvertieren jedes Objekt in einem Paar in einen eingebetteten Vektor mit gleicher Länge. Das Vektorpaar wird an einen Vergleichsoperator übergeben, der die Vektoren in einem einzigen Vektor mit dem Wert zusammensetzt, der im Hyperparameter `comparator_list` angegeben ist. Der zusammengesetzte Vektor wird dann über eine Multi-Layer Perceptron (MLP)-Ebene übergeben, die eine Ausgabe erzeugt, die die Vergleichsfunktion mit den Bezeichnungen vergleicht, die Sie angegeben haben. Bei diesem Vergleich wird die Stärke der Beziehung zwischen den Objekten im Paar wie vom Modell vorhergesagt bewertet. Die folgende Abbildung veranschaulicht diesen Workflow.

![\[Architektur des Object2Vec-Algorithmus von Dateneingaben zu Ergebnissen\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/object2vec-training-image.png)


## Schritt 3: Erstellen von Inferenzen
<a name="object2vec-step-3-inference"></a>

Nachdem das Modell trainiert wurde, können Sie den trainierten Encoder verwenden, um Eingabeobjekte vorzubereiten oder zwei Arten von Inferenzen auszuführen:
+ Zum Konvertieren von Singleton-Eingabeobjekten in Einbettungen mit fester Länge mithilfe des entsprechenden Encoders
+ Zum Voraussagen der Beziehungsbezeichnung oder der Bewertung zwischen einem Paar von Eingabeobjekten

Der Inferenzserver findet auf Grundlage der Eingabedaten automatisch heraus, welche der Arten angefordert wird. Zum Abrufen der Einbettungen als Ausgabe stellen Sie nur eine Eingabe zur Verfügung. Zum Voraussagen der Beziehungsbezeichnung oder der Bewertung stellen Sie beide Eingaben im Paar zur Verfügung.

# Object2Vec-Hyperparameter
<a name="object2vec-hyperparameters"></a>

In der Anforderung `CreateTrainingJob` geben Sie den Trainingsalgorithmus an. Sie können auch algorithmusspezifische Hyperparameter als Maps angeben. string-to-string In der folgenden Tabelle sind die Hyperparameter für den Object2Vec-Trainingsalgorithmus aufgeführt.


| Name des Parameters | Description | 
| --- | --- | 
| enc0\$1max\$1seq\$1len |  Die maximale Squenzlänge für den enc0-Encoder. **Erforderlich** Gültige Werte: 1 ≤ Ganzzahl ≤ 5000  | 
| enc0\$1vocab\$1size |  Die Vokabulargröße von enc0-Token. **Erforderlich** Gültige Werte: 2 ≤ Ganzzahl ≤ 3000000  | 
| bucket\$1width |  Der erlaubte Unterschied zwischen der Datensequenzlänge, wenn Bucketing aktiviert ist. Um das Bucketing zu aktivieren, geben Sie einen Wert ungleich Null für diesen Parameter an. **Optional** Gültige Werte: 0 ≤ Ganzzahl ≤ 100 Standardwert: 0 (kein Bucketing)  | 
| comparator\$1list |  Eine Liste zum Anpassen der Art und Weise, wie zwei Einbettungen verglichen werden. Die Ebene des Object2Vec-Vergleichsoperators nimmt die Kodierungen von beiden Encodern als Eingaben und gibt einen einzelnen Vektor aus. Dieser Vektor ist eine Verkettung von SubVectors. Die Zeichenfolgenwerte, die an die `comparator_list` übergeben werden, sowie die Reihenfolge dieser Übergabe bestimmen, wie diese SubVectors zusammengesetzt werden. Bei `comparator_list="hadamard, concat"` erstellt der Vergleichsoperator beispielsweise den Vektor, indem er das Hadamard-Produkt von zwei Kodierungen und die Verkettung von zwei Kodierungen verkettet. Bei `comparator_list="hadamard"` hingegen erstellt der Vergleichsoperator den Vektor als Hadamard-Produkt von nur zwei Kodierungen.  **Optional** Gültige Werte: Eine Zeichenfolge, die eine beliebige Kombination aus den Namen der drei binären Operatoren enthält: `hadamard`, `concat` oder `abs_diff`. Der Object2Vec-Algorithmus erfordert derzeit, dass die beiden Vektorkodierungen die gleiche Dimension haben. Diese Operatoren erzeugen SubVectors wie folgt: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/object2vec-hyperparameters.html) Standardwert: `"hadamard, concat, abs_diff"`  | 
| dropout |  Die Dropout-Wahrscheinlichkeit Netzwerk-Layer. Bei *Dropout* handelt es sich um eine Form der Regularisierung, die in neuronalen Netzwerken verwendet wird und Überanpassung durch Kürzen koabhängiger Neuronen reduziert. **Optional** Gültige Werte: 0,0 ≤ Gleitkommazahl ≤ 1,0 Standardwert: 0.0  | 
| early\$1stopping\$1patience |  Die Anzahl der aufeinanderfolgenden Epochen ohne Verbesserung, die zulässig ist, bevor das frühzeitige Beenden erfolgt. Verbesserung wird durch den Hyperparameter `early_stopping_tolerance` definiert. **Optional** Gültige Werte: 1 ≤ Ganzzahl ≤ 5 Standardwert: 3  | 
| early\$1stopping\$1tolerance |  Die Verringerung in der Verlustfunktion, die ein Algorithmus zwischen aufeinanderfolgenden Epochen erreichen muss, um ein frühes Anhalten zu vermeiden, nachdem die Anzahl der aufeinanderfolgenden im Hyperparameter `early_stopping_patience` festgelegten Epochen abgeschlossen ist. **Optional** Gültige Werte: 0,000001 ≤ Gleitkommazahl ≤ 0,1 Standardwert: 0.01  | 
| enc\$1dim |  Die Dimension der Ausgabe des einbettenden Layers. **Optional** Gültige Werte: 4 ≤ Ganzzahl ≤ 10000 Standardwert: 4096  | 
| enc0\$1network |  Das Netzwerkmodell für den enc0-Encoder. **Optional** Gültige Werte: `hcnn`, `bilstm` oder `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/object2vec-hyperparameters.html) Standardwert: `hcnn`  | 
| enc0\$1cnn\$1filter\$1width |  Die Filterbreite des Convolutional Neural Network (CNN) enc0-Encoders. **Bedingt** Gültige Werte: 1 ≤ Ganzzahl ≤ 9 Standardwert: 3  | 
| enc0\$1freeze\$1pretrained\$1embedding |  Gibt an, ob mit enc0 vortrainierte Einbettungsgewichtungen eingefroren werden sollen. **Bedingt** Gültige Werte: `True` oder `False`. Standardwert: `True`  | 
| enc0\$1layers  |  Die Anzahl der Layer im enc0-Encoder. **Bedingt** Gültige Werte: `auto` oder 1 ≤ Ganzzahl ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/object2vec-hyperparameters.html) Standardwert: `auto`  | 
| enc0\$1pretrained\$1embedding\$1file |  Der Dateiname der vortrainierten enc0-Token-Einbettungsdatei im zusätzlichen Datenkanal. **Bedingt** Gültige Werte: Zeichenfolge mit alphanumerischen Zeichen, Unterstrich oder Punkt. [A-Za-z0-9\$1.\$1\$1]  Standardwert: "" (eine leere Zeichenfolge)  | 
| enc0\$1token\$1embedding\$1dim |  Die Ausgabedimension des einbettenden Layers des enc0-Tokens. **Bedingt** Gültige Werte: 2 ≤ Ganzzahl ≤ 1000 Standardwert: 300  | 
| enc0\$1vocab\$1file |  Die Vokabeldatei für die Zuordnung vortrainierter enc0-Token-Einbettungsvektoren zum numerischen Vokabular. IDs **Bedingt** Gültige Werte: Zeichenfolge mit alphanumerischen Zeichen, Unterstrich oder Punkt. [A-Za-z0-9\$1.\$1\$1]  Standardwert: "" (eine leere Zeichenfolge)  | 
| enc1\$1network |  Das Netzwerkmodell für den enc1-Encoder. Wenn Sie möchten, dass der enc1-Encoder das gleiche Netzwerkmodell wie enc0 verwendet (einschließlich der Hyperparameterwerte), legen Sie den Wert auf `enc0` fest.   Auch wenn die enc0- und enc1-Encoder-Netzwerke symmetrische Architekturen haben, können Sie Parameterwerte für diese Netzwerke nicht gemeinsam nutzen.  **Optional** Gültige Werte: `enc0`, `hcnn`, `bilstm` oder `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/object2vec-hyperparameters.html) Standardwert: `enc0`  | 
| enc1\$1cnn\$1filter\$1width |  Die Filterbreite des CNN enc1-Encoders. **Bedingt** Gültige Werte: 1 ≤ Ganzzahl ≤ 9 Standardwert: 3  | 
| enc1\$1freeze\$1pretrained\$1embedding |  Gibt an, ob mit enc1 vortrainierte Einbettungsgewichtungen eingefroren werden sollen. **Bedingt** Gültige Werte: `True` oder `False`. Standardwert: `True`  | 
| enc1\$1layers  |  Die Anzahl der Layer im enc1-Encoder. **Bedingt** Gültige Werte: `auto` oder 1 ≤ Ganzzahl ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/object2vec-hyperparameters.html) Standardwert: `auto`  | 
| enc1\$1max\$1seq\$1len |  Die maximale Squenzlänge für den enc1-Encoder. **Bedingt** Gültige Werte: 1 ≤ Ganzzahl ≤ 5000  | 
| enc1\$1pretrained\$1embedding\$1file |  Der Dateiname der vortrainierten enc1-Token-Einbettungsdatei im zusätzlichen Datenkanal. **Bedingt** Gültige Werte: Zeichenfolge mit alphanumerischen Zeichen, Unterstrich oder Punkt. [A-Za-z0-9\$1.\$1\$1]  Standardwert: "" (eine leere Zeichenfolge)  | 
| enc1\$1token\$1embedding\$1dim |  Die Ausgabedimension des einbettenden Layers des enc1-Tokens. **Bedingt** Gültige Werte: 2 ≤ Ganzzahl ≤ 1000 Standardwert: 300  | 
| enc1\$1vocab\$1file |  Die Vokabeldatei für die Zuordnung vortrainierter enc1-Token-Einbettungen zu Vokabeln. IDs **Bedingt** Gültige Werte: Zeichenfolge mit alphanumerischen Zeichen, Unterstrich oder Punkt. [A-Za-z0-9\$1.\$1\$1]  Standardwert: "" (eine leere Zeichenfolge)  | 
| enc1\$1vocab\$1size |  Die Vokabulargröße von enc0-Token. **Bedingt** Gültige Werte: 2 ≤ Ganzzahl ≤ 3000000  | 
| epochs |  Die Anzahl der für das Training auszuführenden Epochen.  **Optional** Gültige Werte: 1 ≤ Ganzzahl ≤ 100 Standardwert: 30  | 
| learning\$1rate |  Die Lernrate für das Training. **Optional** Gültige Werte: 1.0E-6 ≤ Gleitkommazahl ≤ 1,0 Standardwert: 0.0004  | 
| mini\$1batch\$1size |  Die Stapelgröße, in die der Datensatz für einen `optimizer` während des Trainings aufgeteilt wird. **Optional** Gültige Werte: 1 ≤ Ganzzahl ≤ 10000 Standardwert: 32  | 
| mlp\$1activation |  Der Typ der Aktivierungsfunktion für das Multi-Layer-Perceptron (MLP)-Layer. **Optional** Gültige Werte: `tanh`, `relu` oder `linear` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/object2vec-hyperparameters.html) Standardwert: `linear`  | 
| mlp\$1dim |  Die Dimension der Ausgabe von MLP-Layern. **Optional** Gültige Werte: 2 ≤ Ganzzahl ≤ 10000 Standardwert: 512  | 
| mlp\$1layers |  Die Anzahl der MLP-Layer im Netzwerk. **Optional** Gültige Werte: 0 ≤ Ganzzahl ≤ 10 Standardwert: 2  | 
| negative\$1sampling\$1rate |  Das Verhältnis der negativen Stichproben, die generiert wurden, um das Training des Algorithmus zu unterstützen, zu den positiven Stichproben, die von Benutzern bereitgestellt werden. Negative Stichproben stehen für Daten, die in Wirklichkeit wahrscheinlich nicht eintreten, und für das Training negativ gekennzeichnet sind. Sie erleichtern das Training eines Modells, um zwischen den beobachteten positiven Stichproben und den nicht beobachteten negativen Stichproben zu unterscheiden. Um das Verhältnis von negativen zu positiven Stichproben zur Verwendung im Training anzugeben, legen Sie den Wert auf eine positive Ganzzahl fest. Wenn Sie beispielsweise den Algorithmus auf Eingabedaten trainieren, in denen alle Stichproben positiv sind und `negative_sampling_rate` auf 2 festgelegt ist, erzeugt der Object2Vec-Algorithmus intern zwei negative Stichproben pro positiver Stichprobe. Wenn Sie beim Training keine negativen Stichproben generieren oder verwenden möchten, legen Sie den Wert auf 0 fest.  **Optional** Gültige Werte: 0 ≤ Ganzzahl Standardwert: 0 (aus)  | 
| num\$1classes |  Die Anzahl der Klassen für das Klassifizierungstraining. Amazon SageMaker AI ignoriert diesen Hyperparameter bei Regressionsproblemen. **Optional** Gültige Werte: 2 ≤ Ganzzahl ≤ 30 Standardwert: 2  | 
| optimizer |  Der Optimierer-Typ. **Optional** Gültige Werte: `adadelta`, `adagrad`, `adam`, `sgd` oder `rmsprop`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/object2vec-hyperparameters.html) Standardwert: `adam`  | 
| output\$1layer |  Der Typ des Ausgabe-Layers, in dem Sie angeben, dass es sich bei der Aufgabe um eine Regression oder Klassifikation handelt. **Optional** Gültige Werte: `softmax` oder `mean_squared_error`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/object2vec-hyperparameters.html) Standardwert: `softmax`  | 
| tied\$1token\$1embedding\$1weight |  Ob eine gemeinsame Einbettungsebene für beide Encoder verwendet werden soll. Wenn die Eingabewerte für beide Encoder die gleichen Einheiten auf Token-Ebene verwenden, verwenden Sie eine gemeinsame Token-Einbettungsebene. Wenn z. B. für eine Sammlung von Dokumenten ein Encoder Sätze und ein anderer ganze Dokumente kodiert, können Sie eine gemeinsame Token-Einbettungsebene verwenden. Dies liegt daran, dass sowohl Sätze als auch Dokumente aus Wort-Token desselben Vokabulars bestehen. **Optional** Gültige Werte: `True` oder `False`. Standardwert: `False`  | 
| token\$1embedding\$1storage\$1type |  Der während des Trainings verwendete Modus der Gradientenaktualisierung: Bei Verwendung des Modus `dense` berechnet der Optimierer die vollständige Gradientenmatrix für die Token-Einbettungsebene selbst dann, wenn die meisten Zeilen des Gradienten den Wert 0 haben. Wenn der Modus `sparse` verwendet wird, speichert der Optimierer nur Zeilen des Gradienten, die im Mini-Stapel tatsächlich genutzt werden. Wenn Sie möchten, dass der Algorithmus träge Gradientaktualisierungen durchführt, bei denen die Gradienten nur in Nicht-Null-Zeilen berechnet werden, was das Training beschleunigt, geben Sie `row_sparse` an. Wenn der Wert auf `row_sparse` festgelegt ist, werden die für andere Hyperparameter verfügbaren Werte wie folgt eingeschränkt:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/object2vec-hyperparameters.html) **Optional** Gültige Werte: `dense` oder `row_sparse`. Standardwert: `dense`  | 
| weight\$1decay |  Der Weight-Decay-Parameter, der zur Optimierung verwendet wird. **Optional** Gültige Werte: 0 ≤ Gleitkommazahl ≤ 10000 Standardwert: 0 (kein Verfall)  | 

# Optimieren eines Object2Vec-Modells
<a name="object2vec-tuning"></a>

Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Für die objektive Metrik verwenden Sie eine der Metriken, die der Algorithmus berechnet. Bei der automatischen Modelloptimierung werden die ausgewählten Hyperparameter durchsucht, um die Kombination von Werten zu finden, die zu dem Modell führen, das die objektive Metrik optimiert.

Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).

## Vom Object2Vec-Algorithmus berechnete Metriken
<a name="object2vec-metrics"></a>

Der Object2Vec-Algorithmus verfügt sowohl über Klassifizierungs- als auch Regressionsmetriken. Der `output_layer`-Typ bestimmt, welche Metrik Sie für die automatische Modelloptimierung verwenden können. 

### Vom Object2Vec-Algorithmus berechnete Regressormetriken
<a name="object2vec-regressor-metrics"></a>

Der Algorithmus meldet eine Regressormetrik in Form eines mittleren quadratischen Fehlers, die während der Tests und Validierung berechnet wird. Wählen Sie diese Metrik beim Optimieren des Modells für Regressionsaufgaben als objektive Metrik aus.


| Metrikname | Description | Optimierungsrichtung | 
| --- | --- | --- | 
| test:mean\$1squared\$1error | Mittlerer quadratischer Fehler | Minimieren | 
| validation:mean\$1squared\$1error | Mittlerer quadratischer Fehler | Minimieren | 

### Vom Object2Vec-Algorithmus berechnete Klassifizierungsmetriken
<a name="object2vec-classification-metrics"></a>

Der Object2Vec-Algorithmus meldet Genauigkeits- und Kreuz-Entropie-Klassifizierungsmetriken, die bei den Tests und der Validierung berechnet werden. Beim Optimieren des Modell für Klassifizierungsaufgaben wählen Sie eine dieser Metriken als objektive Metrik aus.


| Metrikname | Description | Optimierungsrichtung | 
| --- | --- | --- | 
| test:accuracy | Accuracy | Maximieren | 
| test:cross\$1entropy | Kreuz-Entropie | Minimieren | 
| validation:accuracy | Accuracy | Maximieren | 
| validation:cross\$1entropy | Kreuz-Entropie | Minimieren | 

## Optimierbare Object2Vec-Hyperparameter
<a name="object2vec-tunable-hyperparameters"></a>

Sie können die folgenden Hyperparameter für den Object2Vec-Algorithmus optimieren.


| Name des Hyperparameters | Typ des Hyperparameters | Empfohlene Bereiche und Werte | 
| --- | --- | --- | 
| dropout | ContinuousParameterRange | MinValue: 0,0,: 1,0 MaxValue | 
| early\$1stopping\$1patience | IntegerParameterRange | MinValue: 1, MaxValue: 5 | 
| early\$1stopping\$1tolerance | ContinuousParameterRange | MinValue: 0,001, MaxValue: 0,1 | 
| enc\$1dim | IntegerParameterRange | MinValue: 4, MaxValue: 4096 | 
| enc0\$1cnn\$1filter\$1width | IntegerParameterRange | MinValue: 1, MaxValue: 5 | 
| enc0\$1layers | IntegerParameterRange | MinValue: 1, MaxValue: 4 | 
| enc0\$1token\$1embedding\$1dim | IntegerParameterRange | MinValue: 5, MaxValue: 30 | 
| enc1\$1cnn\$1filter\$1width | IntegerParameterRange | MinValue: 1, MaxValue: 5 | 
| enc1\$1layers | IntegerParameterRange | MinValue: 1, MaxValue: 4 | 
| enc1\$1token\$1embedding\$1dim | IntegerParameterRange | MinValue: 5, MaxValue: 30 | 
| epochs | IntegerParameterRange | MinValue: 4, MaxValue: 20 | 
| learning\$1rate | ContinuousParameterRange | MinValue: 1e-6, MaxValue: 1,0 | 
| mini\$1batch\$1size | IntegerParameterRange | MinValue: 1, MaxValue: 8192 | 
| mlp\$1activation | CategoricalParameterRanges |  [`tanh`, `relu`, `linear`]  | 
| mlp\$1dim | IntegerParameterRange | MinValue: 16, MaxValue 1024 | 
| mlp\$1layers | IntegerParameterRange | MinValue: 1, MaxValue: 4 | 
| optimizer | CategoricalParameterRanges | [`adagrad`, `adam`, `rmsprop`, `sgd`, `adadelta`] | 
| weight\$1decay | ContinuousParameterRange | MinValue: 0,0, MaxValue: 1,0 | 

# Datenformate für das Object2Vec-Training
<a name="object2vec-training-formats"></a>

Stellen Sie beim Training mit dem Object2Vec-Algorithmus sicher, dass die Eingabedaten in Ihrer Anfrage im Format JSON Lines vorliegen, wobei jede Zeile einen einzelnen Datenpunkt darstellt.

## Eingabe: JSONLINES-Anforderungsformat
<a name="object2vec-in-training-data-jsonlines"></a>

Inhaltstyp: application/jsonlines

```
{"label": 0, "in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4], "in1": [16, 21, 13, 45, 14, 9, 80, 59, 164, 4]}
{"label": 1, "in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4], "in1": [22, 32, 13, 25, 1016, 573, 3252, 4]}
{"label": 1, "in0": [774, 14, 21, 206], "in1": [21, 366, 125]}
```

Die Werte "in0" und "in1" sind die Eingaben für encoder0 bzw. encoder1. Das gleiche Format ist sowohl für Klassifizierungs- als auch für Regressionsprobleme gültig. Für die Regression kann das Feld `"label"` (Bezeichnung) reellwertige Eingaben annehmen.

# Datenformate für Object2Vec-Inferenzen
<a name="object2vec-inference-formats"></a>

Auf der folgenden Seite werden die Eingabeanforderungs- und Ausgabeantwortformate für das Abrufen von Bewertungsinferenzen aus dem Amazon SageMaker AI Object2Vec-Modell beschrieben.

## GPU-Optimierung: Klassifizierung oder Regression
<a name="object2vec-inference-gpu-optimize-classification"></a>

Aufgrund der GPU-Speicherknappheit kann die Umgebungsvariable `INFERENCE_PREFERRED_MODE` zur Optimierung angegeben werden, ob die Klassifizierung/Regression oder das [Ausgabe: Encoder-Einbettungen](object2vec-encoder-embeddings.md#object2vec-out-encoder-embeddings-data)-Inferenznetzwerk in die GPU geladen wird. Wenn Ihre Inferenz größtenteils für die Klassifizierung oder Regression bestimmt ist, geben Sie `INFERENCE_PREFERRED_MODE=classification` an. Im Folgenden finden Sie ein Batch-Transform-Beispiel für die Verwendung von 4 Instanzen von p3.2xlarge, das für Inferenz optimiert ist: classification/regression 

```
transformer = o2v.transformer(instance_count=4,
                              instance_type="ml.p2.xlarge",
                              max_concurrent_transforms=2,
                              max_payload=1,  # 1MB
                              strategy='MultiRecord',
                              env={'INFERENCE_PREFERRED_MODE': 'classification'},  # only useful with GPU
                              output_path=output_s3_path)
```

## Eingabe: Klassifizierung oder Regression – Anforderungsformat
<a name="object2vec-in-inference-data"></a>

Inhaltstyp: application/json

```
{
  "instances" : [
    {"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4], "in1": [16, 21, 13, 45, 14, 9, 80, 59, 164, 4]},
    {"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4], "in1": [22, 32, 13, 25, 1016, 573, 3252, 4]},
    {"in0": [774, 14, 21, 206], "in1": [21, 366, 125]}
  ]
}
```

Inhaltstyp: application/jsonlines

```
{"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4], "in1": [16, 21, 13, 45, 14, 9, 80, 59, 164, 4]}
{"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4], "in1": [22, 32, 13, 25, 1016, 573, 3252, 4]}
{"in0": [774, 14, 21, 206], "in1": [21, 366, 125]}
```

Für Klassifizierungsprobleme entspricht die Länge des Bewertungsvektors `num_classes`. Für Regressionsprobleme ist die Länge 1.

## Ausgabe: Klassifizierung oder Regressionsformat
<a name="object2vec-out-inference-data"></a>

Akzeptiert: application/json.

```
{
    "predictions": [
        {
            "scores": [
                0.6533935070037842,
                0.07582679390907288,
                0.2707797586917877
            ]
        },
        {
            "scores": [
                0.026291321963071823,
                0.6577019095420837,
                0.31600672006607056
            ]
        }
    ]
}
```

Akzeptiert: application/jsonlines

```
{"scores":[0.195667684078216,0.395351558923721,0.408980727195739]}
{"scores":[0.251988261938095,0.258233487606048,0.489778339862823]}
{"scores":[0.280087798833847,0.368331134319305,0.351581096649169]}
```

Im Klassifizierungs- wie auch im Regressionsformat entspricht die Bewertung der jeweiligen Bezeichnung. 

# Encoder-Einbettungen für Object2Vec
<a name="object2vec-encoder-embeddings"></a>

Auf der folgenden Seite sind die Eingabeanforderungs- und Ausgabeantwortformate für das Abrufen von Inferenzen zur Encoder-Einbettung aus dem Amazon SageMaker AI Object2Vec-Modell aufgeführt.

## GPU-Optimierung: Encoder-Einbettungen
<a name="object2vec-inference-gpu-optimize-encoder-embeddings"></a>

Eine Einbettung ist eine Zuweisung von diskreten Objekten, wie Wörtern, zu Vektoren realer Zahlen.

Aufgrund der GPU-Speicherknappheit kann die Umgebungsvariable `INFERENCE_PREFERRED_MODE` zur Optimierung angegeben werden, ob die [Datenformate für Object2Vec-Inferenzen](object2vec-inference-formats.md) oder das Encoder-Einbettungsinferenznetzwerk in die GPU geladen wird. Wenn Ihre Inferenz größtenteils Encoder-Einbettungen bestimmt ist, geben Sie `INFERENCE_PREFERRED_MODE=embedding` an. Im Folgenden finden Sie ein Beispiel für eine Stapeltransformation mit 4 p3.2xlarge-Instances, das die Encoder-Einbettungsinferenz optimiert:

```
transformer = o2v.transformer(instance_count=4,
                              instance_type="ml.p2.xlarge",
                              max_concurrent_transforms=2,
                              max_payload=1,  # 1MB
                              strategy='MultiRecord',
                              env={'INFERENCE_PREFERRED_MODE': 'embedding'},  # only useful with GPU
                              output_path=output_s3_path)
```

## Eingabe: Encoder-Einbettungen
<a name="object2vec-in-encoder-embeddings-data"></a>

Inhaltstyp: application/json; infer\$1max\$1seqlens=<FWD-LENGTH>,<BCK-LENGTH>

Wo <FWD-LENGTH> und <BCK-LENGTH> Ganzzahlen im Bereich [1.5000] sind und die maximalen Sequenzlängen für den Vorwärts- und Rückwärts-Encoder definieren.

```
{
  "instances" : [
    {"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4]},
    {"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4]},
    {"in0": [774, 14, 21, 206]}
  ]
}
```

Inhaltstyp: application/jsonlines; infer\$1max\$1seqlens=<FWD-LENGTH>,<BCK-LENGTH>

Wo <FWD-LENGTH> und <BCK-LENGTH> Ganzzahlen im Bereich [1.5000] sind und die maximalen Sequenzlängen für den Vorwärts- und Rückwärts-Encoder definieren.

```
{"in0": [6, 17, 606, 19, 53, 67, 52, 12, 5, 10, 15, 10178, 7, 33, 652, 80, 15, 69, 821, 4]}
{"in0": [22, 1016, 32, 13, 25, 11, 5, 64, 573, 45, 5, 80, 15, 67, 21, 7, 9, 107, 4]}
{"in0": [774, 14, 21, 206]}
```

In beiden dieser Formate geben Sie nur einen Eingabetyp an, und zwar entweder `“in0”` oder `“in1.”`. Der Inferenzservice ruft dann den entsprechenden Encoder auf und gibt die Einbettungen für jede der Instances aus. 

## Ausgabe: Encoder-Einbettungen
<a name="object2vec-out-encoder-embeddings-data"></a>

Inhaltstyp: application/json

```
{
  "predictions": [
    {"embeddings":[0.057368703186511,0.030703511089086,0.099890425801277,0.063688032329082,0.026327300816774,0.003637571120634,0.021305780857801,0.004316598642617,0.0,0.003397724591195,0.0,0.000378780066967,0.0,0.0,0.0,0.007419463712722]},
    {"embeddings":[0.150190666317939,0.05145975202322,0.098204270005226,0.064249359071254,0.056249320507049,0.01513972133398,0.047553978860378,0.0,0.0,0.011533712036907,0.011472506448626,0.010696629062294,0.0,0.0,0.0,0.008508535102009]}
  ]
}
```

Inhaltstyp: application/jsonlines

```
{"embeddings":[0.057368703186511,0.030703511089086,0.099890425801277,0.063688032329082,0.026327300816774,0.003637571120634,0.021305780857801,0.004316598642617,0.0,0.003397724591195,0.0,0.000378780066967,0.0,0.0,0.0,0.007419463712722]}
{"embeddings":[0.150190666317939,0.05145975202322,0.098204270005226,0.064249359071254,0.056249320507049,0.01513972133398,0.047553978860378,0.0,0.0,0.011533712036907,0.011472506448626,0.010696629062294,0.0,0.0,0.0,0.008508535102009]}
```

Die Vektorlänge der vom Inferenzservice ausgegebenen Einbettungen ist gleich dem Wert eines der folgenden Hyperparameter, die Sie zum Trainingszeitpunkt angeben: `enc0_token_embedding_dim`, `enc1_token_embedding_dim` oder `enc_dim`.

# Sequence-to-Sequence Algorithmus
<a name="seq-2-seq"></a>

Amazon SageMaker AI Sequence to Sequence ist ein überwachter Lernalgorithmus, bei dem die Eingabe eine Sequenz von Tokens (z. B. Text, Audio) und die generierte Ausgabe eine weitere Token-Sequenz ist. Zu den Anwendungsbeispielen gehören: maschinelle Übersetzung (Eingabe eines Satzes aus einer Sprache und Vorhersage, wie dieser Satz in einer anderen Sprache lauten würde), Textzusammenfassung (Eingabe einer längeren Wortfolge und Vorhersage einer kürzeren Wortfolge, die eine Zusammenfassung ist), speech-to-text (Audioclips, die in Ausgabesätze in Tokens umgewandelt werden). Kürzlich konnten Probleme in diesem Bereich erfolgreich mit tiefen neuronalen Netzwerken modelliert werden, die eine erhebliche Leistungssteigerung im Vergleich zu früheren Methoden bieten. Amazon SageMaker AI seq2seq verwendet Recurrent Neural Networks (RNNs) und Convolutional Neural Network (CNN) -Modelle mit besonderer Aufmerksamkeit als Encoder-Decoder-Architekturen. 

**Topics**
+ [

## Sequence-to-SequenceEingabe-/Ausgabeschnittstelle für den Algorithmus
](#s2s-inputoutput)
+ [

## Empfehlung für eine Sequence-to-Sequence EC2-Instanz für den Algorithmus
](#s2s-instances)
+ [

## Sequence-to-Sequence Beispiel-Notizbücher
](#seq-2-seq-sample-notebooks)
+ [

# Funktionsweise von Sequence-to-Sequence
](seq-2-seq-howitworks.md)
+ [

# Sequence-to-Sequence Hyperparameter
](seq-2-seq-hyperparameters.md)
+ [

# Tunen Sie ein Sequence-to-Sequence Modell
](seq-2-seq-tuning.md)

## Sequence-to-SequenceEingabe-/Ausgabeschnittstelle für den Algorithmus
<a name="s2s-inputoutput"></a>

**Training**

SageMaker AI seq2seq erwartet Daten im Recordio-ProtoBUF-Format. Die Token werden jedoch als Ganzzahlen und nicht als Gleitkommazahlen erwartet, wie es normalerweise der Fall ist.

Ein Skript zum Konvertieren von Daten aus Token-Textdateien in das "protobuf"-Format ist im [Beispiel-Notebook für seq2seq](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html) enthalten. Das Skript packt die Daten in Tensoren (32 Bit, Ganzzahl) und generiert die für Metrikberechnung und Inferenz erforderlichen Vokabeldateien.

Nachdem die Vorverarbeitung abgeschlossen ist, kann der Algorithmus für Trainings aufgerufen werden. Der Algorithmus erwartet drei Kanäle:
+ `train`: Dieser Kanal enthält das Trainingsdaten (z. B. die vom Vorverarbeitungsskript generierte `train.rec`-Datei).
+ `validation`: Dieser Kanal enthält die Validierungsdaten (z. B. die vom Vorverarbeitungsskript generierte `val.rec`-Datei).
+ `vocab`: Dieser Kanal enthält die beiden Vokabeldateien (`vocab.src.json` und `vocab.trg.json`). 

Falls der Algorithmus in einem dieser drei Kanäle keine Daten findet, verläuft das Training fehlerhaft.

**Inferenz**

Für gehostete Endpunkte werden für die Inferenz zwei Datenformate unterstützt. Für die Inferenzausführung mit durch Leerzeichen getrennte Text-Token verwenden Sie das Format `application/json`. Andernfalls verwenden Sie das Format `recordio-protobuf`, um die codierten Ganzzahldaten zu nutzen. Beide Modi unterstützen ein Batching der Eingabedaten. Das `application/json`-Format ermöglicht außerdem eine Visualisierung der Attention-Matrix.
+ `application/json`: Für Ein- und Ausgabe wird das JSON-Format verwendet. Sowohl die Inhalts- als auch die Annahmetypen sollten das Format `application/json` aufweisen. Jede Sequenz muss eine Zeichenfolge mit durch Leerzeichen getrennte Token sein. Dieses Format wird empfohlen, wenn im Stapel nur eine geringe Anzahl an Quellsequenzen vorhanden ist. Außerdem werden folgende zusätzliche Konfigurationsoptionen unterstützt:

  `configuration`: \$1`attention_matrix`: `true`\$1: Gibt die Attention-Matrix für eine bestimmte Eingabesequenz zurück.
+ `application/x-recordio-protobuf`: Die Eingabe muss im `recordio-protobuf`-Format erfolgen, für die Ausgabe wird ebenfalls das `recordio-protobuf format`-Format verwendet. Sowohl die Inhalts- als auch die Annahmetypen sollten das Format `applications/x-recordio-protobuf` aufweisen. Bei diesem Format müssen die Quellsequenzen für die nachfolgende "protobuf"-Codierung in eine Liste mit Ganzzahlen konvertiert werden. Dieses Format wird für die Masseninferenz empfohlen.

Für die Stapeltransformation unterstützt die Inferenz das JSON Lines-Format. Für Stapeltransformationen wird für die Eingabe das JSON Lines-Format verwendet und die Ausgabe wird ebenfalls im JSON Lines-Format zurückgegeben. Sowohl die Inhalts- als auch die Annahmetypen sollten das Format `application/jsonlines` aufweisen. Das Format für die Eingabe lautet folgendermaßen:

```
content-type: application/jsonlines

{"source": "source_sequence_0"}
{"source": "source_sequence_1"}
```

Das Format für die Antwort lautet folgendermaßen:

```
accept: application/jsonlines

{"target": "predicted_sequence_0"}
{"target": "predicted_sequence_1"}
```

Weitere Informationen zur Serialisierung und Deserialisierung der Ein- und Ausgaben in bestimmte Formate für Inferenzzwecke finden Sie unter [Sequence-to-Sequence Beispiel-Notizbücher](#seq-2-seq-sample-notebooks).

## Empfehlung für eine Sequence-to-Sequence EC2-Instanz für den Algorithmus
<a name="s2s-instances"></a>

Der Amazon SageMaker AI seq2seq-Algorithmus unterstützt nur GPU-Instance-Typen und kann nur auf einem einzigen Computer trainiert werden. Sie können jedoch Instances mit mehreren verwenden. GPUs Der seq2seq-Algorithmus unterstützt die GPU-Instancefamilien P2, P3, G4dn und G5.

## Sequence-to-Sequence Beispiel-Notizbücher
<a name="seq-2-seq-sample-notebooks"></a>

Ein Beispielnotizbuch, das zeigt, wie der Algorithmus SageMaker AI Sequence to Sequence verwendet wird, um ein Englisch-Deutsch-Übersetzungsmodell zu trainieren, finden Sie unter [Beispiel für maschinelle Übersetzung Englisch-Deutsch](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html) mit AI Seq2Seq. SageMaker Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instanzen, mit denen Sie das Beispiel in KI ausführen können, finden Sie unter. SageMaker [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie den Tab **SageMaker KI-Beispiele** aus, um eine Liste aller KI-Beispiele zu sehen. SageMaker Die Beispiel-Notebooks zur Themenmodellierung unter Verwendung der NTM-Algorithmen finden Sie im Abschnitt **Einführung in die Amazon-Algorithmen**. Zum Öffnen eines Notebooks klicken Sie auf die Registerkarte **Use (Verwenden)** und wählen Sie **Create copy (Kopie erstellen)** aus.

# Funktionsweise von Sequence-to-Sequence
<a name="seq-2-seq-howitworks"></a>

In der Regel besteht ein neuronales Netzwerk für die sequence-to-sequence Modellierung aus einigen Schichten, darunter: 
+ Ein **einbettender Layer**. In diesem Layer mit der Eingabematrix werden die "platzsparend" codierten Eingabe-Token (z. B. per One-Hot-Codierung) einem Funktions-Layer mit hoher Dichte zugeordnet. Dies ist erforderlich, da ein hochdimensionaler Merkmalsvektor Informationen zu einem bestimmten Token (Wort für Textkorpora) besser kodieren kann als ein einfacher one-hot-encoded Vektor. Es ist auch üblich, diese Einbettungsschicht mit einem vortrainierten Wortvektor wie [FastText](https://fasttext.cc/)oder [Glove](https://nlp.stanford.edu/projects/glove/) zu initialisieren oder sie nach dem Zufallsprinzip zu initialisieren und die Parameter während des Trainings zu lernen. 
+ Ein **Encoder-Layer**. Nachdem die Eingabe-Token einem hochdimensionalen Funktionsraum zugeordnet wurden, wird die Sequenz über einen Encoder-Layer übergeben, um alle Informationen aus dem einbettenden Eingabe-Layer (der gesamten Sequenz) in einen Funktionsvektor mit fester Größe zu komprimieren. In der Regel besteht ein Encoder aus Netzwerken des RNN-Typs, wie LSTM (Long Short-Term Memory) oder GRUs (Gated Recurrent Units). (In[ Colah's blog](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) wird LSTM ausführlich erläutert.) 
+ Ein **Decoder-Layer**. Der Decoder-Layer verwendet diesen codierten Funktionsvektor und generiert die Token-Ausgabesequenz. Dieser Layer setzt sich üblicherweise aus RNN-Architekturen (LSTM und GRU) zusammen. 

Das gesamte Modell wird gemeinsam trainiert, um die Wahrscheinlichkeit der Zielsequenz anhand der Quellsequenz zu maximieren. Dieses Modell wurde erstmals von [Sutskever et al.](https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf) im Jahre 2014 vorgestellt. 

**Attention-Mechanismus**. Der Nachteil eines Encoder-Decoder-Frameworks besteht darin, dass die Modellleistung mit zunehmender Länge der Quellsequenz abnimmt. Das liegt daran, dass der codierte Funktionsvektor mit fester Länge nur eine bestimmte Menge an Informationen aufnehmen kann. Zur Behebung dieses Problems führten Bahdanau et al. im Jahre 2015 den [Attention-Mechanismus](https://arxiv.org/pdf/1409.0473.pdf) ein. In einem Attention-Mechanismus versucht der Decoder, die Stelle mit den wichtigsten Informationen in der Encoder-Sequenz zu ermitteln, und nutzt diese Informationen sowie zuvor decodierte Wörter, um das nächste Token in der Sequenz zu prognostizieren. 

Weitere Informationen sowie erläuterte und vereinfachte Berechnungen verschiedener Attention-Mechanismen finden Sie im Whitepaper [Effective Approaches to Attention-based Neural Machine Translation](https://arxiv.org/abs/1508.04025) von Luong et al. Zudem wird im Whitepaper [Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation](https://arxiv.org/abs/1609.08144) von Wu et al. die zur Maschinenübersetzung von Google eingesetzte Architektur beschrieben, in der Skip-Connections zwischen Encoder- und Decoder-Layer verwendet werden.

# Sequence-to-Sequence Hyperparameter
<a name="seq-2-seq-hyperparameters"></a>

In der folgenden Tabelle sind die Hyperparameter aufgeführt, die Sie beim Training mit dem Amazon SageMaker AI-Algorithmus Sequence-to-Sequence (seq2seq) festlegen können.


| Name des Parameters | Description | 
| --- | --- | 
| batch\$1size | Mini-Stapelgröße für das Gradientenverfahren. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 64 | 
| beam\$1size | Beam-Länge für die Beam-Suche. Wird während des Trainings zur `bleu`-Berechnung und im Rahmen der Inferenzausführung verwendet. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 5 | 
| bleu\$1sample\$1size | Anzahl der Instances, die aus dem Validierungsdatensatz zur Decodierung und Berechnung der `bleu`-Bewertung während des Trainings ausgewählt werden sollen. Legen Sie den Wert auf -1 fest, um einen vollständigen Validierungssatz zu verwenden (sofern `bleu` als `optimized_metric` ausgewählt wurde). **Optional** Gültige Werte: Ganzzahl Standardwert: 0 | 
| bucket\$1width | Gibt (Quell-/Ziel-) Buckets mit bis zu (`max_seq_len_source`, `max_seq_len_target`) zurück. Die längere Seite der Daten verwendet Schritte von, `bucket_width` während die kürzere Seite Schritte verwendet, die um das durchschnittliche Längenverhältnis herunterskaliert sind. target/source Wenn eine Seite die maximale Länge vor der anderen Seite erreicht, wird die Breite zusätzlicher Buckets für diese Seite auf den `max_len`-Wert dieser Seite festgelegt. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 10 | 
| bucketing\$1enabled | Mit `false` wird Bucketing deaktiviert, Unrolling für maximale Länge. **Optional** Gültige Werte: `true` oder `false`. Standardwert: `true` | 
| checkpoint\$1frequency\$1num\$1batches | Prüfpunkt und Auswertung alle x Stapel. Dieser Checkpoint-Hyperparameter wird an den seq2seq-Algorithmus der SageMaker KI übergeben, damit er das System frühzeitig stoppt und das beste Modell abruft. Das Checkpointing des Algorithmus wird lokal im Trainingscontainer des Algorithmus ausgeführt und ist nicht mit KI-Checkpointing kompatibel. SageMaker Der Algorithmus speichert Checkpoints vorübergehend in einem lokalen Pfad und speichert das beste Modellartefakt im Modellausgabepfad in S3, nachdem der Trainingsauftrag beendet wurde. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 1000 | 
| checkpoint\$1threshold | Maximale Anzahl an Prüfpunkten, die das Modell in `optimized_metric` des Validierungsdatensatzes nicht korrigieren darf, bevor das Training gestoppt wird. Dieser Checkpoint-Hyperparameter wird an den seq2seq-Algorithmus der SageMaker KI übergeben, um ihn frühzeitig zu stoppen und das beste Modell abzurufen. Das Checkpointing des Algorithmus wird lokal im Trainingscontainer des Algorithmus ausgeführt und ist nicht mit KI-Checkpointing kompatibel. SageMaker Der Algorithmus speichert Checkpoints vorübergehend in einem lokalen Pfad und speichert das beste Modellartefakt im Modellausgabepfad in S3, nachdem der Trainingsauftrag beendet wurde. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 3 | 
| clip\$1gradient | Absolute Gradientenwerte, die diesen Wert überschreiten, abschneiden. Zur Deaktivierung auf einen negativen Wert setzen. **Optional** Gültige Werte: Gleitkommazahl Standardwert: 1 | 
| cnn\$1activation\$1type | Gibt den zu verwendenden `cnn`-Aktivierungstyp an. **Optional** Gültige Werte: Zeichenfolge. Einer der Werte `glu`, `relu`, `softrelu`, `sigmoid` oder `tanh`. Standardwert: `glu` | 
| cnn\$1hidden\$1dropout | Dropout-Wahrscheinlichkeit für einen Ausfall von Convolutional (faltenden)-Layern. **Optional** Gültige Werte: Gleitkommazahl. Bereich [0,1]. Standardwert: 0 | 
| cnn\$1kernel\$1width\$1decoder | Kernelbreite für den `cnn`-Decoder. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 5 | 
| cnn\$1kernel\$1width\$1encoder | Kernelbreite für den `cnn`-Encoder. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 3 | 
| cnn\$1num\$1hidden | Anzahl der ausgeblendeten `cnn`-Einheiten für Encoder und Decoder. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 512 | 
| decoder\$1type | Decoder-Typ. **Optional** Gültige Werte: Zeichenfolge. Entweder `rnn` oder `cnn`. Standardwert: *rnn* | 
| embed\$1dropout\$1source | Dropout-Wahrscheinlichkeit für Einbettungen aufseiten der Quelle. **Optional** Gültige Werte: Gleitkommazahl. Bereich [0,1]. Standardwert: 0 | 
| embed\$1dropout\$1target | Dropout-Wahrscheinlichkeit für Einbettungen aufseiten des Ziels. **Optional** Gültige Werte: Gleitkommazahl. Bereich [0,1]. Standardwert: 0 | 
| encoder\$1type | Encoder-Typ. Die `rnn`-Architektur basiert auf dem Attention-Mechanismus von Bahdanau et al. und die *cnn*-Architektur stammt von Gehring et al. **Optional** Gültige Werte: Zeichenfolge. Entweder `rnn` oder `cnn`. Standardwert: `rnn` | 
| fixed\$1rate\$1lr\$1half\$1life | Halbwertzeit der Lernrate in Bezug auf die Prüfpunktanzahl von `fixed_rate_`\$1-Schedulern. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 10 | 
| learning\$1rate | Anfängliche Lernrate. **Optional** Gültige Werte: Gleitkommazahl Standardwert: 0.0003 | 
| loss\$1type | Verlustfunktion für Trainings. **Optional** Gültige Werte: Zeichenfolge `cross-entropy` Standardwert: `cross-entropy` | 
| lr\$1scheduler\$1type | Scheduler-Typ der Lernrate. Mit `plateau_reduce` wird die Lernrate mit jedem`optimized_metric`-Wert auf `validation_accuracy`-Plateaus reduziert. `inv_t` steht für inversen zeitlichen Verfall. `learning_rate`/(1\$1`decay_rate`\$1t) **Optional** Gültige Werte: Zeichenfolge. Entweder `plateau_reduce`, `fixed_rate_inv_t` oder `fixed_rate_inv_sqrt_t`. Standardwert: `plateau_reduce` | 
| max\$1num\$1batches | Maximale Anzahl von updates/batches zu verarbeitenden. -1 für unendlich. **Optional** Gültige Werte: Ganzzahl Standardwert: -1 | 
| max\$1num\$1epochs | Maximale Anzahl der Epochen, die die Trainingsdaten durchlaufen können, bevor die Anpassung beendet wird. Das Training wird so lange fortgesetzt, bis diese Anzahl von Epochen erreicht ist (auch wenn die Validierungsgenauigkeit nicht durch die Übergabe dieses Parameters verbessert wird). Wird dieser Parameter nicht übergeben, wird er ignoriert. **Optional** Gültige Werte: Eine positive Ganzzahl und kleiner als oder gleich max\$1num\$1epochs. Standardwert: keine | 
| max\$1seq\$1len\$1source | Maximale Länge der Quellsequenz. Längere Sequenzen werden auf diese Länge gekürzt. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 100  | 
| max\$1seq\$1len\$1target | Maximale Länge der Zielsequenz. Längere Sequenzen werden auf diese Länge gekürzt. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 100 | 
| min\$1num\$1epochs | Mindestanzahl der Epochen, die das Training ausgeführt werden muss, bevor sie über `early_stopping`-Bedingungen angehalten wird. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 0 | 
| momentum | Für `sgd` verwendete Momentum-Konstante. Übergeben Sie diesen Parameter nicht, wenn Sie `adam` oder `rmsprop` nutzen. **Optional** Gültige Werte: Gleitkommazahl Standardwert: keine | 
| num\$1embed\$1source | Einbettende Größe für Quell-Token. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 512 | 
| num\$1embed\$1target | Einbettende Größe für Ziel-Token. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 512 | 
| num\$1layers\$1decoder | Layer-Anzahl für den Decoder-Typ *rnn* oder *cnn*. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 1 | 
| num\$1layers\$1encoder | Layer-Anzahl für den Encoder-Typ `rnn` oder `cnn`. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 1 | 
| optimized\$1metric | Metriken zur Optimierung des frühzeitigen Beendens. **Optional** Gültige Werte: Zeichenfolge. Entweder `perplexity`, `accuracy` oder `bleu`. Standardwert: `perplexity` | 
| optimizer\$1type | Auswählbare Optimierung. **Optional** Gültige Werte: Zeichenfolge. Entweder `adam`, `sgd` oder `rmsprop`. Standardwert: `adam` | 
| plateau\$1reduce\$1lr\$1factor | Faktor der Lernratenmultiplikation (für `plateau_reduce`). **Optional** Gültige Werte: Gleitkommazahl Standardwert: 0.5 | 
| plateau\$1reduce\$1lr\$1threshold | Beim `plateau_reduce`-Scheduler wird die Lernrate mit einem Reduzierungsfaktor multipliziert, wenn `optimized_metric` durch diese zahlreichen Prüfpunkte nicht verbessert werden konnte. **Optional** Gültige Werte: positive Ganzzahl Standardwert: 3 | 
| rnn\$1attention\$1in\$1upper\$1layers | Attention-Übergabe an die oberen *rnn*-Layer wie Google NMT-paper Dies ist nur möglich, wenn mehrere Layer verwendet werden. **Optional** Gültige Werte: Boolesch (`true` oder `false`) Standardwert: `true` | 
| rnn\$1attention\$1num\$1hidden | Anzahl der ausgeblendeten Einheiten für Attention-Layer. Der Standardwert ist `rnn_num_hidden`. **Optional** Gültige Werte: positive Ganzzahl Standardwert: `rnn_num_hidden` | 
| rnn\$1attention\$1type | Attention-Modell für Encoder. `mlp` bezieht sich auf "concat" und bilinear bezieht sich auf "general" im Whitepaper von Luong et al. **Optional** Gültige Werte: Zeichenfolge. Einer der Werte `dot`, `fixed`, `mlp` oder `bilinear`. Standardwert: `mlp` | 
| rnn\$1cell\$1type | Spezifischer Typ der `rnn`-Architektur. **Optional** Gültige Werte: Zeichenfolge. Entweder `lstm` oder `gru`. Standardwert: `lstm` | 
| rnn\$1decoder\$1state\$1init | Gibt an, wie Status von `rnn`-Decodern aus Encodern initialisiert werden. **Optional** Gültige Werte: Zeichenfolge. Entweder `last`, `avg` oder `zero`. Standardwert: `last` | 
| rnn\$1first\$1residual\$1layer | Erster *rnn*-Layer mit einer residualen Verbindung (nur möglich, sofern die Anzahl der Layer im Encoder oder Decoder mehr als 1 beträgt). **Optional** Gültige Werte: positive Ganzzahl Standardwert: 2 | 
| rnn\$1num\$1hidden | Anzahl der ausgeblendeten *rnn*-Einheiten für Encoder und Decoder. Dieser Wert muss ein Vielfaches von 2 sein, da der Algorithmus standardmäßig den bidirektionalen Langzeit-Kurzzeitspeicher (LSTM, Long Term Short Term Memory) verwendet. **Optional** Gültige Werte: positive gerade Ganzzahl Standardwert: 1024 | 
| rnn\$1residual\$1connections | Fügt eine residuale Verbindung zum gestapelten *rnn* hinzu. Die Anzahl der Layer muss mehr als 1 betragen. **Optional** Gültige Werte: Boolesch (`true` oder `false`) Standardwert: `false` | 
| rnn\$1decoder\$1hidden\$1dropout | Dropout-Wahrscheinlichkeit für ausgeblendeten Status als Kombination aus Kontext und ausgeblendetem *rnn*-Status im Decoder. **Optional** Gültige Werte: Gleitkommazahl. Bereich [0,1]. Standardwert: 0 | 
| training\$1metric | Metriken zur Trainingsüberwachung mithilfe von Validierungsdaten. **Optional** Gültige Werte: Zeichenfolge. Entweder `perplexity` oder `accuracy`. Standardwert: `perplexity` | 
| weight\$1decay | Konstante des Gewichtungszerfalls. **Optional** Gültige Werte: Gleitkommazahl Standardwert: 0 | 
| weight\$1init\$1scale | Skala der Gewichtungsinitialisierung (für Initialisierungen der Typen `uniform` und `xavier`).  **Optional** Gültige Werte: Gleitkommazahl Standardwert: 2.34 | 
| weight\$1init\$1type | Typ der Gewichtungsinitialisierung.  **Optional** Gültige Werte: Zeichenfolge. Entweder `uniform` oder `xavier`. Standardwert: `xavier` | 
| xavier\$1factor\$1type | Xavier-Faktortyp. **Optional** Gültige Werte: Zeichenfolge. Entweder `in`, `out` oder `avg`. Standardwert: `in` | 

# Tunen Sie ein Sequence-to-Sequence Modell
<a name="seq-2-seq-tuning"></a>

Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik aus den Metriken aus, die der Algorithmus berechnet. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.

Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).

## Vom Algorithmus berechnete Metriken Sequence-to-Sequence
<a name="seq-2-seq-metrics"></a>

Der Sequence-to-Sequence-Algorithmus meldet drei Metriken, die während des Trainingsen berechnet werden. Wählen Sie eine davon als Ziel für die Optimierung aus, wenn die Hyperparameterwerte optimiert werden.


| Metrikname | Description | Optimierungsrichtung | 
| --- | --- | --- | 
| validation:accuracy |  Die für den Validierungsdatensatz berechnete Genauigkeit.  |  Maximieren  | 
| validation:bleu |  Für den Validierungsdatensatz berechnete [Bleu](https://en.wikipedia.org/wiki/BLEU)-Bewertung. Da die BLEU-Berechnung teuer ist, können Sie BLEU anhand einer nach dem Zufallsprinzip ermittelten Teilstichprobe des Validierungsdatensatzes berechnen lassen, um den gesamten Trainingsprozess zu beschleunigen. Für die Angabe der Teilstichprobe verwenden Sie den `bleu_sample_size`-Parameter.  |  Maximieren  | 
| validation:perplexity |  [Perplexity](https://en.wikipedia.org/wiki/Perplexity) ist eine Verlustfunktion, die für den Validierungsdatensatz berechnet wird. „Perplexity“ misst die Kreuz-Entropie zwischen einer empirischen Stichprobe und der vom Modell prognostizierten Verteilung und bietet so ein Maß dafür, wie gut ein Modell die Stichprobenwerte prognositiziert. Modelle, die eine Stichprobe gut voraussagen können, haben einen niedrigen Perplexity-Wert.  |  Minimieren  | 

## Einstellbare Hyperparameter Sequence-to-Sequence
<a name="seq-2-seq-tunable-hyperparameters"></a>

Sie können die folgenden Hyperparameter für den SageMaker AI Sequence-to-Sequence-Algorithmus einstellen. Die Hyperparameter mit den größten Auswirkungen auf objektive Sequence-to-Sequence-Metriken sind: `batch_size`, `optimizer_type`, `learning_rate`, `num_layers_encoder` und `num_layers_decoder`.


| Name des Parameters | Parametertyp | Empfohlene Bereiche | 
| --- | --- | --- | 
| num\$1layers\$1encoder |  IntegerParameterRange  |  [1-10]  | 
| num\$1layers\$1decoder |  IntegerParameterRange  |  [1-10]  | 
| batch\$1size |  CategoricalParameterRange  |  [16,32,64,128,256,512,1024,2048]  | 
| optimizer\$1type |  CategoricalParameterRange  |  ['adam', 'sgd', 'rmsprop']  | 
| weight\$1init\$1type |  CategoricalParameterRange  |  ['xavier', 'uniform']  | 
| weight\$1init\$1scale |  ContinuousParameterRange  |  Für den Xavier-Typ: MinValue: 2.0, MaxValue: 3.0 Für den einheitlichen Typ:: -1.0, MinValue: 1.0 MaxValue  | 
| learning\$1rate |  ContinuousParameterRange  |  MinValue: 0,00005,: 0,2 MaxValue  | 
| weight\$1decay |  ContinuousParameterRange  |  MinValue: 0,0, MaxValue: 0,1  | 
| momentum |  ContinuousParameterRange  |  MinValue: 0,5, MaxValue: 0,9  | 
| clip\$1gradient |  ContinuousParameterRange  |  MinValue: 1,0, MaxValue: 5,0  | 
| rnn\$1num\$1hidden |  CategoricalParameterRange  |  Gilt nur für rekurrente neuronale Netze (RNNs). [128,256,512,1024,2048]   | 
| cnn\$1num\$1hidden |  CategoricalParameterRange  |  Gilt nur für neuronale Faltungsnetze (). CNNs [128,256,512,1024,2048]   | 
| num\$1embed\$1source |  IntegerParameterRange  |  [256-512]  | 
| num\$1embed\$1target |  IntegerParameterRange  |  [256-512]  | 
| embed\$1dropout\$1source |  ContinuousParameterRange  |  MinValue: 0,0,: 0,5 MaxValue  | 
| embed\$1dropout\$1target |  ContinuousParameterRange  |  MinValue: 0,0, MaxValue: 0,5  | 
| rnn\$1decoder\$1hidden\$1dropout |  ContinuousParameterRange  |  MinValue: 0,0, MaxValue: 0,5  | 
| cnn\$1hidden\$1dropout |  ContinuousParameterRange  |  MinValue: 0,0, MaxValue: 0,5  | 
| lr\$1scheduler\$1type |  CategoricalParameterRange  |  ['plateau\$1reduce', 'fixed\$1rate\$1inv\$1t', 'fixed\$1rate\$1inv\$1sqrt\$1t']  | 
| plateau\$1reduce\$1lr\$1factor |  ContinuousParameterRange  |  MinValue: 0,1, MaxValue: 0,5  | 
| plateau\$1reduce\$1lr\$1threshold |  IntegerParameterRange  |  [1-5]  | 
| fixed\$1rate\$1lr\$1half\$1life |  IntegerParameterRange  |  [10-30]  | 

# Textklassifizierung - TensorFlow
<a name="text-classification-tensorflow"></a>

Der Amazon SageMaker AI Text Classification — TensorFlow Algorithmus ist ein überwachter Lernalgorithmus, der Transfer-Lernen mit vielen vortrainierten Modellen aus dem [TensorFlow Hub](https://tfhub.dev/) unterstützt. Verwenden Sie Transfer Learning, um eines der verfügbaren vortrainierten Modelle anhand Ihres eigenen Datensatzes zu optimieren, auch wenn eine große Menge an Textdaten nicht verfügbar ist. Der Textklassifizierungsalgorithmus verwendet eine Textzeichenfolge als Eingabe und gibt für jede Klassenbezeichnung eine Wahrscheinlichkeit aus. Trainingsdatensätze müssen im CSV-Format vorliegen. Diese Seite enthält Informationen zu Amazon EC2 EC2-Instance-Empfehlungen und Beispielnotizbücher für Text Classification - TensorFlow.

**Topics**
+ [

# Wie benutzt man den SageMaker AI Text Classification — Algorithmus TensorFlow
](text-classification-tensorflow-how-to-use.md)
+ [

# Eingabe- und Ausgabeschnittstelle für den TensorFlow Textklassifizierungsalgorithmus
](text-classification-tensorflow-inputoutput.md)
+ [

## Amazon EC2 EC2-Instance-Empfehlung für den Textklassifizierungsalgorithmus TensorFlow
](#text-classification-tensorflow-instances)
+ [

## Textklassifizierung — TensorFlow Beispiele für Notizbücher
](#text-classification-tensorflow-sample-notebooks)
+ [

# So TensorFlow funktioniert die Textklassifizierung
](text-classification-tensorflow-HowItWorks.md)
+ [

# TensorFlow Hub-Modelle
](text-classification-tensorflow-Models.md)
+ [

# Textklassifizierung — TensorFlow Hyperparameter
](text-classification-tensorflow-Hyperparameter.md)
+ [

# Optimieren Sie ein Textklassifizierungsmodell TensorFlow
](text-classification-tensorflow-tuning.md)

# Wie benutzt man den SageMaker AI Text Classification — Algorithmus TensorFlow
<a name="text-classification-tensorflow-how-to-use"></a>

Sie können Text Classification TensorFlow als integrierten Algorithmus von Amazon SageMaker AI verwenden. Im folgenden Abschnitt wird beschrieben, wie Sie Text Classification verwenden — TensorFlow mit dem SageMaker AI Python SDK. Informationen zur Verwendung TensorFlow von Text Classification — über die Amazon SageMaker Studio Classic-Benutzeroberfläche — finden Sie unter[SageMaker JumpStart vortrainierte Modelle](studio-jumpstart.md).

Der TensorFlow Textklassifizierungsalgorithmus unterstützt Transfer-Learning unter Verwendung eines der kompatiblen vortrainierten TensorFlow Modelle. Eine Liste aller verfügbaren vortrainierten Modelle finden Sie unter [TensorFlow Hub-Modelle](text-classification-tensorflow-Models.md). Jedes vortrainierte Modell hat ein Unikat `model_id`. Im folgenden Beispiel wird BERT Base Uncased (`model_id`:`tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2`) zur Feinabstimmung eines benutzerdefinierten Datensatzes verwendet. Die vortrainierten Modelle werden alle vorab vom TensorFlow Hub heruntergeladen und in Amazon S3 S3-Buckets gespeichert, sodass Trainingsjobs netzwerkisoliert ausgeführt werden können. Verwenden Sie diese vorgenerierten Modelltrainingsartefakte, um einen AI Estimator zu erstellen. SageMaker 

Rufen Sie zunächst den Docker-Image-URI, den Trainingsskript-URI und den vortrainierten Modell-URI ab. Ändern Sie dann die Hyperparameter nach Bedarf. Sie können ein Python-Wörterbuch mit allen verfügbaren Hyperparametern und ihren Standardwerten mit `hyperparameters.retrieve_default` sehen. Weitere Informationen finden Sie unter [Textklassifizierung — TensorFlow Hyperparameter](text-classification-tensorflow-Hyperparameter.md). Verwenden Sie diese Werte, um einen SageMaker AI-Schätzer zu erstellen.

**Anmerkung**  
Die Standard-Hyperparameterwerte sind für verschiedene Modelle unterschiedlich. Bei größeren Modellen ist die Standardstapelgröße beispielsweise kleiner. 

In diesem Beispiel wird der [https://www.tensorflow.org/datasets/catalog/glue#gluesst2](https://www.tensorflow.org/datasets/catalog/glue#gluesst2)Datensatz verwendet, der positive und negative Filmkritiken enthält. Wir haben den Datensatz vorab heruntergeladen und mit Amazon S3 verfügbar gemacht. Rufen Sie zur Feinabstimmung Ihres Modells an, `.fit` indem Sie den Amazon S3-Speicherort Ihres Trainingsdatensatzes verwenden. Jeder in einem Notebook verwendete S3-Bucket muss sich in derselben AWS Region befinden wie die Notebook-Instanz, die darauf zugreift.

```
from sagemaker import image_uris, model_uris, script_uris, hyperparameters
from sagemaker.estimator import Estimator

model_id, model_version = "tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2", "*"
training_instance_type = "ml.p3.2xlarge"

# Retrieve the Docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)

# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")

# Retrieve the pretrained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")

# Retrieve the default hyperparameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)

# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"

# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/SST2/"

training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"

output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tc-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"

# Create an Estimator instance
tf_tc_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
    output_path=s3_output_location,
)

# Launch a training job
tf_tc_estimator.fit({"training": training_dataset_s3_path}, logs=True)
```

Weitere Informationen zur Verwendung des SageMaker TensorFlow Textklassifizierungsalgorithmus für Transfer-Lernen in einem benutzerdefinierten Datensatz finden Sie im Notizbuch [Einführung in die JumpStart Textklassifikation](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).

# Eingabe- und Ausgabeschnittstelle für den TensorFlow Textklassifizierungsalgorithmus
<a name="text-classification-tensorflow-inputoutput"></a>

Jedes der in TensorFlow Hub-Modellen aufgelisteten vortrainierten Modelle kann auf jeden Datensatz abgestimmt werden, der aus Textsätzen mit einer beliebigen Anzahl von Klassen besteht. Das vortrainierte Modell fügt dem Text Embedding-Modell eine Klassifizierungsebene hinzu und initialisiert die Ebenenparameter mit Zufallswerten. Die Ausgabedimension der Klassifikationsschicht wird anhand der Anzahl der in den Eingabedaten erkannten Klassen bestimmt. 

Achten Sie darauf, wie Sie Ihre Trainingsdaten für die Eingabe in das Textklassifizierungsmodell formatieren. TensorFlow 
+ **Eingabeformat für Trainingsdaten:** Ein Verzeichnis, das eine `data.csv` Datei enthält. Jede Zeile der ersten Spalte sollte ganzzahlige Klassenbezeichnungen zwischen 0 und der Anzahl der Klassen haben. Jede Zeile der zweiten Spalte sollte die entsprechenden Textdaten enthalten.

Im Folgenden finden Sie ein Beispiel für eine CSV-Eingabedatei. Beachten Sie, dass die Datei keinen Header haben sollte. Die Datei sollte in einem Amazon-S3-Bucket mit einem Pfad gehostet werden, der dem folge nden ähnelt: `s3://bucket_name/input_directory/`. Beachten Sie, dass das Trailing `/` erforderlich ist.

```
|   |  |
|---|---|
|0 |hide new secretions from the parental units|
|0 |contains no wit , only labored gags|
|1 |that loves its characters and communicates something rather beautiful about human nature|
|...|...|
```

## Inkrementelles Training
<a name="text-classification-tensorflow-incremental-training"></a>

Sie können das Training eines neuen Modells mit Artefakten aus einem Modell beginnen, das Sie zuvor mit SageMaker KI trainiert haben. Dieses inkrementelle Training verkürzt die Trainingsdauer, wenn Sie ein neues Modell mit denselben oder ähnlichen Daten trainieren möchten.

**Anmerkung**  
Sie können ein SageMaker TensorFlow KI-Textklassifizierungsmodell nur mit einem anderen, in SageMaker KI trainierten TensorFlow Textklassifizierungsmodell auswerten. 

Sie können jeden Datensatz für das inkrementelle Training verwenden, solange der Klassensatz derselbe bleibt. Der inkrementelle Trainingsschritt ähnelt dem Feinabstimmungsschritt, aber anstatt mit einem vortrainierten Modell zu beginnen, beginnen Sie mit einem vorhandenen fein abgestimmten Modell. 

Weitere Informationen zur Verwendung von inkrementellem Training mit dem SageMaker TensorFlow AI-Textklassifizierungsalgorithmus finden Sie im Beispielnotizbuch [Einführung in die Textklassifizierung](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb). JumpStart 

## Inferenz mit dem Textklassifizierungsalgorithmus TensorFlow
<a name="text-classification-tensorflow-inference"></a>

Sie können das fein abgestimmte Modell, das aus Ihrem TensorFlow Textklassifizierungstraining resultiert, als Inferenz hosten. Alle Rohtextformate für Inferenzen müssen vom Inhaltstyp sein `application/x-text` .

Das Ausführen von Inferenzen führt zu Wahrscheinlichkeitswerten, Klassenbezeichnungen für alle Klassen und dem vorhergesagten Label, das dem Klassenindex mit der höchsten Wahrscheinlichkeit entspricht, kodiert im JSON-Format. Das TensorFlow Textklassifizierungsmodell verarbeitet eine einzelne Zeichenfolge pro Anfrage und gibt nur eine Zeile aus. Nachfolgend finden Sie ein Beispiel für eine Antwort im JSON Lines-Format:

```
accept: application/json;verbose

{"probabilities": [prob_0, prob_1, prob_2, ...],
"labels": [label_0, label_1, label_2, ...],
"predicted_label": predicted_label}
```

Wenn `accept` auf `application/json` gesetzt ist, gibt das Modell nur Wahrscheinlichkeiten aus. 

## Amazon EC2 EC2-Instance-Empfehlung für den Textklassifizierungsalgorithmus TensorFlow
<a name="text-classification-tensorflow-instances"></a>

Der TensorFlow Textklassifizierungsalgorithmus unterstützt alle CPU- und GPU-Instances für das Training, einschließlich:
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`
+ `ml.g4dn.xlarge`
+ `ml.g4dn.16.xlarge`
+ `ml.g5.xlarge`
+ `ml.g5.48xlarge`

Wir empfehlen die Verwendung von GPU-Instances mit mehr Arbeitsspeicher zum Training mit großen Stapelgrößen. Sowohl CPU- (wie M5) als auch GPU-Instances (P2, P3, G4dn oder G5) können für Inferenzen verwendet werden. Eine umfassende Liste der SageMaker Trainings- und Inferenzinstanzen in allen AWS Regionen finden Sie unter [ SageMaker Amazon-Preise](https://aws.amazon.com/sagemaker/pricing/).

## Textklassifizierung — TensorFlow Beispiele für Notizbücher
<a name="text-classification-tensorflow-sample-notebooks"></a>

Weitere Informationen zur Verwendung des SageMaker TensorFlow AI-Textklassifizierungsalgorithmus für Transfer-Lernen an einem benutzerdefinierten Datensatz finden Sie im Notizbuch [Einführung in die JumpStart Textklassifizierung](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).

Anweisungen zum Erstellen und Zugreifen auf Jupyter-Notebook-Instanzen, mit denen Sie das Beispiel in SageMaker KI ausführen können, finden Sie unter. [SageMaker Amazon-Notebook-Instanzen](nbi.md) Nachdem Sie eine Notebook-Instanz erstellt und geöffnet haben, wählen Sie die Registerkarte **SageMaker KI-Beispiele** aus, um eine Liste aller KI-Beispiele anzuzeigen. SageMaker Zum Öffnen eines Notebooks wählen Sie die Registerkarte **Verwenden** und dann **Kopie erstellen** aus.

# So TensorFlow funktioniert die Textklassifizierung
<a name="text-classification-tensorflow-HowItWorks"></a>

Der TensorFlow Algorithmus zur Textklassifizierung verwendet Text bei der Klassifizierung und ordnet ihn einer der Ausgabeklassenbezeichnungen zu. Deep-Learning-Netzwerke wie [BERT](https://arxiv.org/pdf/1810.04805.pdf) sind bei der Textklassifizierung sehr genau. Es gibt auch Deep-Learning-Netzwerke, die mit großen Textdatensätzen trainiert werden TextNet, z. B. mit mehr als 11 Millionen Texten mit etwa 11.000 Kategorien. Nachdem ein Netzwerk mit TextNet Daten trainiert wurde, können Sie das Netzwerk anhand eines Datensatzes mit einem bestimmten Schwerpunkt feinabstimmen, um spezifischere Textklassifizierungsaufgaben auszuführen. Der Amazon SageMaker AI Text Classification — TensorFlow Algorithmus unterstützt Transfer Learning auf vielen vortrainierten Modellen, die im TensorFlow Hub verfügbar sind.

Je nach Anzahl der Klassenbezeichnungen in Ihren Trainingsdaten wird dem vortrainierten TensorFlow Modell Ihrer Wahl eine Textklassifizierungsebene angehängt. Die Klassifikationsschicht besteht aus einem Dropout-Layer, einem dichten Layer und einem vollständig verbundenen Layer mit 2-Norm-Regularisierung und wird mit zufälligen Gewichten initialisiert. Sie können die Hyperparameterwerte für die Dropout-Rate der Dropout-Ebene und den L2-Regularisierungsfaktor für die dichte Schicht ändern.

Sie können entweder das gesamte Netzwerk (einschließlich des vortrainierten Modells) oder nur die oberste Klassifikationsebene auf neue Trainingsdaten abstimmen. Mit dieser Methode des Transfer-Learnings ist ein Training mit kleineren Datensätzen möglich.

# TensorFlow Hub-Modelle
<a name="text-classification-tensorflow-Models"></a>

Die folgenden vortrainierten Modelle können für das Transferlernen mit dem TensorFlow Textklassifizierungsalgorithmus verwendet werden. 

Die folgenden Modelle unterscheiden sich erheblich in Größe, Anzahl der Modellparameter, Trainingszeit und Inferenzlatenz für einen bestimmten Datensatz. Welches Modell am besten für Ihren Anwendungsfall geeignet ist, hängt von der Komplexität Ihres Feinabstimmungsdatensatzes und allen Anforderungen ab, die Sie an Trainingszeit, Inferenzlatenz oder Modellgenauigkeit haben.


| Modellname | `model_id` | Quelle | 
| --- | --- | --- | 
|  BERT-Base ohne Hülle  | `tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3) | 
|  BERT-Basisgehäuse  | `tensorflow-tc-bert-en-cased-L-12-H-768-A-12-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3) | 
|  BERT Base Mehrsprachiges Gehalten  | `tensorflow-tc-bert-multi-cased-L-12-H-768-A-12-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3) | 
|  Kleines BERT L-2\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-128-A-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1) | 
|  Kleines BERT L-2\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-256-A-4` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1) | 
|  Kleines BERT L-2\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-512-A-8` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1) | 
|  Kleines BERT L-2\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-768-A-12` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1) | 
|  Kleines BERT L-4\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-128-A-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1) | 
|  Kleines BERT L-4\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-256-A-4` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1) | 
|  Kleines BERT L-4\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-512-A-8` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1) | 
|  Kleines BERT L-4\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-768-A-12` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1) | 
|  Kleines BERT L-6\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-128-A-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1) | 
|  Kleines BERT L-6\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-256-A-4` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1) | 
|  Kleines BERT L-6\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-512-A-8` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1) | 
|  Kleines BERT L-6\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-768-A-12` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1) | 
|  Kleines BERT L-8\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-128-A-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1) | 
|  Kleines BERT L-8\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-256-A-4` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1) | 
|  Kleines BERT L-8\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-512-A-8` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1) | 
|  Kleines BERT L-8\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-768-A-12` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1) | 
|  Kleines BERT L-10\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-128-A-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1) | 
|  Kleines BERT L-10\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-256-A-4` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1) | 
|  Kleiner BERT L-10\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-512-A-8` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1) | 
|  Kleiner BERT L-10\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-768-A-12` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1) | 
|  Kleines BERT L-12\$1H-128\$1A-2  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-128-A-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1) | 
|  Kleines BERT L-12\$1H-256\$1A-4  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-256-A-4` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1) | 
|  Kleines BERT L-12\$1H-512\$1A-8  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-512-A-8` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1) | 
|  Kleines BERT L-12\$1H-768\$1A-12  | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-768-A-12` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1) | 
|  BERT Large ohne Hülle  | `tensorflow-tc-bert-en-uncased-L-24-H-1024-A-16-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/3) | 
|  BERT Großkoffer  | `tensorflow-tc-bert-en-cased-L-24-H-1024-A-16-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/bert_en_cased_L-24_H-1024_A-16/3) | 
|  BERT Große Ganzwortmaskierung ohne Groß- und Kleinschreibung  | `tensorflow-tc-bert-en-wwm-uncased-L-24-H-1024-A-16-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/bert_en_wwm_uncased_L-24_H-1024_A-16/3) | 
|  BERT Maskierung ganzer Wörter in Großbuchstaben  | `tensorflow-tc-bert-en-wwm-cased-L-24-H-1024-A-16-2` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/bert_en_wwm_cased_L-24_H-1024_A-16/3) | 
|  ALBERT-Untergestell  | `tensorflow-tc-albert-en-base` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/albert_en_base/2) | 
|  ELECTRA Small \$1\$1  | `tensorflow-tc-electra-small-1` | [TensorFlow Hub-Verbindung](https://tfhub.dev/google/electra_small/2) | 
|  ELECTRA-Basis  | `tensorflow-tc-electra-base-1` | [TensorFlow Hub-Verbindung](https://tfhub.dev/google/electra_base/2) | 
|  BERT Base Wikipedia und BooksCorpus  | `tensorflow-tc-experts-bert-wiki-books-1` | [TensorFlow Hub-Link](https://tfhub.dev/google/experts/bert/wiki_books/2) | 
|  BERT-Basis MEDLINE/ PubMed  | `tensorflow-tc-experts-bert-pubmed-1` | [TensorFlow Hub-Verbindung](https://tfhub.dev/google/experts/bert/pubmed/2) | 
|  Talking Heads Base  | `tensorflow-tc-talking-heads-base` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1) | 
|  Talking Heads groß  | `tensorflow-tc-talking-heads-large` | [TensorFlow Hub-Verbindung](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_large/1) | 

# Textklassifizierung — TensorFlow Hyperparameter
<a name="text-classification-tensorflow-Hyperparameter"></a>

Hyperparameter sind Parameter, die festgelegt werden, bevor ein Machine-Learning-Modell mit dem Lernen beginnt. Die folgenden Hyperparameter werden vom in Amazon SageMaker AI integrierten TensorFlow Objekterkennungsalgorithmus unterstützt. Weitere Informationen zur Hyperparameter-Optimierung finden Sie unter [Optimieren Sie ein Textklassifizierungsmodell TensorFlow](text-classification-tensorflow-tuning.md). 


| Name des Parameters | Description | 
| --- | --- | 
| batch\$1size |  Die Batch-Größe für das Training. Für das Training auf Instances mit mehreren GPUs wird diese Batchgröße überall verwendet. GPUs  Gültige Werte: positive Ganzzahl. Standardwert: `32`.  | 
| beta\$11 |  Die Beta1-Version für die`"adam"` und die `"adamw"` Optimierer. Stellt die exponentielle Zerfallsrate für die Schätzungen des ersten Moments dar. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.9`.  | 
| beta\$12 |  Die Beta2 für die Optimierer sind `"adam"` und `"adamw"`. Stellt die exponentielle Abklingrate für die Schätzungen des zweiten Moments dar. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.999`.  | 
| dropout\$1rate | Die Dropout-Rate für die Dropout-Schicht in der obersten Klassifizierungsschicht. Wird nur verwendet, wenn für `reinitialize_top_layer` der Wert `"True"` festgelegt ist. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.2` | 
| early\$1stopping |  Setz auf `"True"`, um die Logik zum Early-Stopping während des Trainings zu verwenden. Falls `"False"`, wird vorzeitiges Abbrechen nicht verwendet. Gültige Werte: Zeichenfolge, entweder: (`"True"` oder `"False"`). Standardwert: `"False"`.  | 
| early\$1stopping\$1min\$1delta | Die geringste Änderung, die erforderlich ist, um als Verbesserung zu gelten. Eine absolute Änderung, die unter dem Wert von early\$1stopping\$1min\$1delta liegt, gilt nicht als Verbesserung. Wird nur verwendet, wenn für early\$1stopping der Wert "True" festgelegt ist.Gültige Werte: Float, Bereich: [`0.0`, `1.0`].Standardwert: `0.0`. | 
| early\$1stopping\$1patience |  Die Anzahl der Epochen, in denen die Ausbildung ohne Verbesserung fortgesetzt wird. Wird nur verwendet, wenn für `early_stopping` der Wert `"True"` festgelegt ist. Gültige Werte: positive Ganzzahl. Standardwert: `5`.  | 
| epochs |  Die Anzahl der Trainingsepochen. Gültige Werte: positive Ganzzahl. Standardwert: `10`.  | 
| epsilon |  Das Epsilon für `"adam"`, `"rmsprop"`, `"adadelta"`, und `"adagrad"`. Normalerweise auf einen kleinen Wert eingestellt, um eine Division durch 0 zu vermeiden. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `1e-7`.  | 
| initial\$1accumulator\$1value |  Der Startwert für die Akkumulatoren oder die Impulswerte pro Parameter für den `"adagrad"` Optimierer. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.0001`.  | 
| learning\$1rate | Die Lernrate des Optimierers. Gültige Werte: Float, Bereich: [`0.0`, `1.0`].Standardwert: `0.001`. | 
| momentum |  Der Schwung für die `"sgd"` und `"nesterov"` Optimierer. Wird für andere Optimierer ignoriert. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.9`.  | 
| optimizer |  Der Optimierer-Typ. Weitere Informationen finden Sie in der [Dokumentation unter Optimizer](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers). TensorFlow  Gültige Werte: Zeichenfolge, einer der folgenden Werte: (`"adamw"`, `"adam"`, `"sgd"`, `"nesterov"`, `"rmsprop"`, ` "adagrad"` , `"adadelta"`). Standardwert: `"adam"`.  | 
| regularizers\$1l2 |  Der L2-Regularisierungsfaktor für die dichte Schicht in der Klassifizierungsschicht. Wird nur verwendet, wenn für `reinitialize_top_layer` der Wert `"True"` festgelegt ist. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.0001`.  | 
| reinitialize\$1top\$1layer |  Wenn dieser Wert auf `"Auto"` gesetzt ist, werden die Parameter der obersten Klassifikationsschicht während der Feinabstimmung neu initialisiert. Beim inkrementellen Training werden die Parameter der obersten Klassifikationsschicht nur dann neu initialisiert, wenn sie auf `"True"` gesetzt sind. Gültige Werte: Zeichenfolge, einer der folgenden Werte: (`"Auto"`, `"True"` oder `"False"`). Standardwert: `"Auto"`.  | 
| rho |  Der Abzinsungsfaktor für den Gradienten der `"adadelta"` und `"rmsprop"` Optimierer. Wird für andere Optimierer ignoriert.  Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.95`.  | 
| train\$1only\$1on\$1top\$1layer |  Falls `"True"`, werden nur die Parameter der obersten Klassifikationsschicht fein abgestimmt. Falls `"False"`, werden alle Modellparameter fein abgestimmt. Gültige Werte: Zeichenfolge, entweder: (`"True"` or `"False"`). Standardwert: `"False"`.  | 
| validation\$1split\$1ratio |  Der Anteil der Trainingsdaten, der nach dem Zufallsprinzip aufgeteilt werden soll, um Validierungsdaten zu erstellen. Wird nur verwendet, wenn keine Validierungsdaten über den `validation` Kanal bereitgestellt werden. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.2`.  | 
| warmup\$1steps\$1fraction |  Der Bruchteil der Gesamtzahl der Gradientenaktualisierungsschritte, bei denen die Lernrate beim Aufwärmen von 0 auf die anfängliche Lernrate ansteigt. Wird nur mit dem `adamw` Optimizer verwendet. Gültige Werte: Float, Bereich: [`0.0`, `1.0`]. Standardwert: `0.1`.  | 

# Optimieren Sie ein Textklassifizierungsmodell TensorFlow
<a name="text-classification-tensorflow-tuning"></a>

Die *automatische Modelloptimierung*, auch bekannt als Hyperparameteroptimierung, sucht die beste Version eines Modells, indem viele Aufträge ausgeführt werden, die einen Bereich von Hyperparametern in Ihrem Datensatz testen. Sie wählen die optimierbaren Hyperparameter, eine Reihe von Werten für jeden Parameter und eine objektive Metrik aus. Sie wählen die objektive Metrik aus den Metriken aus, die der Algorithmus berechnet. Die automatische Modelloptimierung durchsucht die ausgewählten Hyperparameter nach der Kombination von Werten, die das Modell ergeben, das die objektive Metrik optimiert.

Mehr Informationen über die Modelloptimierung finden Sie unter [Automatische Modelloptimierung mit KI SageMaker](automatic-model-tuning.md).

## Mit dem Textklassifizierungsalgorithmus berechnete Metriken TensorFlow
<a name="text-classification-tensorflow-metrics"></a>

In der folgenden Tabelle können Sie herausfinden, welche Metriken vom Textklassifizierungsalgorithmus berechnet werden. TensorFlow 


| Metrikname | Description | Optimierungsrichtung | Regex-Muster | 
| --- | --- | --- | --- | 
| validation:accuracy | Das Verhältnis der Anzahl von richtigen Prognosen zur Gesamtzahl der erstellten Voraussagen. | Maximieren | `val_accuracy=([0-9\\.]+)` | 

## Einstellbare Textklassifizierung — Hyperparameter TensorFlow
<a name="text-classification-tensorflow-tunable-hyperparameters"></a>

Stimmen Sie ein Textklassifikationsmodell mit den folgenden Hyperparametern ab. Die Hyperparameter mit den größten Auswirkungen auf die objektiven Metriken der Bildklassifizierung sind: `batch_size`, `learning_rate` und `optimizer`. Optimieren Sie die auf den Optimierer bezogenen Hyperparameter, wie `momentum`, `regularizers_l2`, `beta_1`, `beta_2`, `eps` und , basierend auf dem ausgewählten `optimizer`. Verwenden Sie z. B. `beta_1` und `beta_2` nur, wenn `adamw` oder `adam` der `optimizer` ist.

Weitere Informationen dazu, welche Hyperparameter für die `optimizer` einzelnen Parameter verwendet werden, finden Sie unter [Textklassifizierung — TensorFlow Hyperparameter](text-classification-tensorflow-Hyperparameter.md).


| Name des Parameters | Parametertyp | Empfohlene Bereiche | 
| --- | --- | --- | 
| batch\$1size | IntegerParameterRanges | MinValue: 4, MaxValue: 128 | 
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6, MaxValue: 0,99 | 
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6,: 0,999 MaxValue | 
| eps | ContinuousParameterRanges | MinValue: 1e-8,: 1,0 MaxValue | 
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6,: 0,5 MaxValue | 
| momentum | ContinuousParameterRanges | MinValue: 0,0,: 0,99 MaxValue | 
| optimizer | CategoricalParameterRanges | ['adamw', 'adam', 'sgd', 'rmsprop', 'nesterov', 'adagrad', 'adadelta'] | 
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0,0, MaxValue: 0,99 | 
| train\$1only\$1on\$1top\$1layer | CategoricalParameterRanges | ['True', 'False'] |