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.
# Object2Vec-Algorithmus
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
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
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
+ [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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Inhaltstyp: application/json; infer\$1max\$1seqlens=,
Wo und 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=,
Wo und 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
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`.