Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Algorithme Object2Vec
L'algorithme Amazon SageMaker AI Object2Vec est un algorithme d'intégration neuronale à usage général hautement personnalisable. Il peut apprendre les intégrations denses à faible dimension des objets à haute dimension. Les intégrations sont apprises de manière à ce que la sémantique de la relation entre les paires d'objets de l'espace d'origine soit conservée dans le script d'intégration. Vous pouvez utiliser les intégrations apprises pour, par exemple, calculer efficacement les voisins les plus proches d'objets et visualiser les clusters naturels d'objets connexes dans l'espace à faible dimension. Vous pouvez également utiliser les intégrations comme caractéristiques des objets correspondants des tâches supervisées en aval, telles que la classification ou la régression.
Object2Vec généralise la célèbre technique d'intégration Word2Vec pour les mots optimisés dans l'IA. SageMaker [BlazingText algorithme](blazingtext.md) Pour un article de blog expliquant comment appliquer Object2Vec à certains cas d'utilisation pratiques, consultez Introduction [à Amazon SageMaker ](https://aws.amazon.com/blogs/machine-learning/introduction-to-amazon-sagemaker-object2vec/) AI Object2Vec.
**Topics**
+ [Interface d'entrée/sortie pour l'algorithme Object2Vec](#object2vec-inputoutput)
+ [Recommandation d'instance EC2 pour l'algorithme Object2Vec](#object2vec--instances)
+ [Exemples de blocs-notes Object2Vec](#object2vec-sample-notebooks)
+ [Fonctionnement d'Object2Vec](object2vec-howitworks.md)
+ [Hyperparamètres Object2Vec](object2vec-hyperparameters.md)
+ [Régler un modèle Object2Vec](object2vec-tuning.md)
+ [Format de données pour l'entraînement d'Object2Vec](object2vec-training-formats.md)
+ [Format de données pour l'inférence d'Object2Vec](object2vec-inference-formats.md)
+ [Intégrations de l'encodeur pour Object2Vec](object2vec-encoder-embeddings.md)
## Interface d'entrée/sortie pour l'algorithme Object2Vec
Vous pouvez utiliser Object2Vec sur différents types de données d'entrée, y compris les éléments suivants :
| Type de données d’entrée | Exemple |
| --- | --- |
| Paires phrase-phrase | « Un match de foot avec plusieurs hommes qui jouent. » et « Certains hommes font du sport. » |
| Paire étiquettes-séquence | Les balises de genre du film « Titanic », par exemple « ROMANCE » et « Drame » et sa brève description : « Titanic de James Cameron est un film d'action romantique et épique qui raconte l'histoire tragique du navire Titanic. Ce navire de croisière était le plus luxueux de son époque, un bateau de rêve, qui a mené plus de 1 500 personnes à la mort dans les eaux glacées de l'Atlantique Nord aux premières heures du jour du 15 avril 1912. » |
| Paires client-client | L'ID client Jane et ID client Jackie. |
| Paires produit-produit | L'ID produit football et l'ID produit basket-ball |
| Paires utilisateur-élément de révision d'élément | Un ID d'utilisateur et les éléments qu'elle a achetés, tels que des pommes, des poires et des oranges. |
Pour transformer les données d'entrée dans les formats pris en charge, vous devez les prétraiter. De façon native, Object2Vec prend actuellement en charge deux types d'entrée :
+ Un jeton discret, qui est représenté sous la forme d'une liste d'un seul `integer-id`. Par exemple, `[10]`.
+ Une séquence de jetons discrets, qui est représentée sous la forme d'une liste de `integer-ids`. Par exemple, `[0,12,10,13]`.
L'objet de chaque paire peut être asymétrique. Par exemple, les paires peuvent être (jeton, séquence) ou (jeton, jeton) ou (séquence, séquence). Pour les entrées de jeton, l'algorithme prend en charge les intégrations simples comme encodeurs compatibles. Pour les séquences de vecteurs de jetons, l'algorithme prend en charge les éléments suivants comme encodeurs :
+ Moyenne des intégrations de pools
+ réseaux neuronaux convolutifs hiérarchiques ()CNNs,
+ Mémoire bidirectionnelle multicouche à long terme (Bi) LSTMs
L'étiquette d'entrée pour chaque paire peut être l'une des actions suivantes :
+ Une étiquette de catégorie qui exprime la relation entre les objets dans la paire
+ Un score qui exprime la puissance de la similarité entre les deux objets
Pour les étiquettes de catégorie utilisées dans la classification, l'algorithme prend en charge la fonction perte entropie croisée. Pour les étiquettes basées sur les évaluations/scores utilisées dans la régression, l'algorithme prend en charge la fonction d'erreur quadratique moyenne. Spécifiez ces fonctions de perte avec l'hyperparamètre `output_layer` lorsque vous créez la tâche d'entraînement du modèle.
## Recommandation d'instance EC2 pour l'algorithme Object2Vec
Le type d'instance Amazon Elastic Compute Cloud (Amazon EC2) que vous utilisez dépend de si vous entraînez ou exécutez l'inférence.
Lors de l'entraînement d'un modèle à l'aide de l'algorithme Object2Vec sur une UC, commencez par une instance ml.m5.2xlarge. Pour les entraînements sur un GPU, commencez par une instance ml.p2.xlarge. Si l'entraînement prend trop de temps sur cette instance, vous pouvez utiliser une instance plus grande. Actuellement, l'algorithme Object2Vec permet d'entraîner sur une seule machine. Cependant, il offre un support pour plusieurs GPUs. Object2Vec prend en charge les familles d'instances de GPU P2, P3, G4dn et G5 pour l'entraînement et l'inférence.
Pour une inférence dotée d'un modèle Object2Vec entraîné qui comporte un réseau de neurones profond, nous vous recommandons d'utiliser l'instance GPU ml.p3.2xlarge. La mémoire GPU étant faible, la variable d'environnement `INFERENCE_PREFERRED_MODE` peut être spécifiée pour déterminer si le réseau d'inférence [Optimisation du GPU : classification ou régression](object2vec-inference-formats.md#object2vec-inference-gpu-optimize-classification) ou [Optimisation du GPU : intégrations de l'encodeur](object2vec-encoder-embeddings.md#object2vec-inference-gpu-optimize-encoder-embeddings) doit être chargé dans le GPU.
## Exemples de blocs-notes Object2Vec
+ [Utilisation d'Object2Vec pour encoder des phrases dans des intégrations de longueur fixe](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/object2vec_sentence_similarity/object2vec_sentence_similarity.html)
# Fonctionnement d'Object2Vec
Lorsque vous utilisez l'algorithme Amazon SageMaker AI Object2Vec, vous suivez le flux de travail standard : traiter les données, entraîner le modèle et produire des inférences.
**Topics**
+ [Étape 1 : Traitement des données](#object2vec-step-1-data-preprocessing)
+ [Étape 2 : Entraîner un modèle](#object2vec-step-2-training-model)
+ [Étape 3 : Produire les inférences](#object2vec-step-3-inference)
## Étape 1 : Traitement des données
Pendant le prétraitement, convertissez les données au format de fichier texte [Lignes JSON](http://jsonlines.org/) spécifié dans [Format de données pour l'entraînement d'Object2Vec](object2vec-training-formats.md). Pour obtenir la plus haute précision au cours de l'entraînement et réorganiser de façon aléatoire les données avant de les alimenter dans le modèle. La façon dont vous générez des permutations aléatoires dépend de la langue. Pour Python, vous pouvez utiliser `np.random.shuffle` ; pour Unix, `shuf`.
## Étape 2 : Entraîner un modèle
L'algorithme SageMaker AI Object2Vec comporte les principaux composants suivants :
+ **Deux canaux d'entrée** : les 2 canaux d'entrée acceptent une paire d'objets du même type ou de types différents comme entrées, et les transmettent à des encodeurs personnalisables et indépendants.
+ **Deux encodeurs** : les encodeurs enc0 et enc1 convertissent chaque objet en un vecteur d'intégration de longueur fixe. Intégrations encodées des objets de la paire, qui sont ensuite transmises à un comparateur.
+ **Comparateur** : le comparateur compare les intégrations de différentes manières et génère des scores qui indiquent la force de la relation entre les objets associés pour chaque type de relation spécifiée par l'utilisateur. Dans le score de sortie pour une paire de phrases. Par exemple, 1 indique une relation forte entre une paire de phrases et 0 représente une relation faible.
Au moment de l'entraînement, l'algorithme accepte les paires d'objets et leurs étiquettes ou scores de relation comme entrées. Les objets dans chaque paire peuvent être de différents types, comme indiqué plus tôt. Si les entrées pour les deux encodeurs sont composées de la même façon au niveau des unités, vous pouvez utiliser un jeton partagé ou intégrer une couche en définissant l'hyperparamètre `tied_token_embedding_weight` sur `True` lorsque vous créez la tâche d'entraînement. Cela est possible, par exemple, lors de la comparaison de phrases qui ont toutes les deux des unités de mot au niveau du jeton. Pour générer des exemples négatifs à un rythme déterminé, définissez l'hyperparamètre `negative_sampling_rate` sur le ratio souhaité exemples positifs/négatifs. Cet hyperparamètre accélère l'apprentissage de la distinction entre les exemples positifs observés dans les données d'entraînement et les exemples négatifs qui ont peu de probabilités d'être observés.
Ils sont transmis via des encodeurs indépendants et personnalisables, qui sont compatibles avec les types d'entrée des objets correspondants Les encodeurs convertissent chaque objet d'une paire en un vecteur d'intégration à longueur fixe d'égale longueur. La paire de vecteurs est transmise à un opérateur de comparaison, qui regroupe les vecteurs dans un vecteur unique à l'aide de la valeur spécifiée dans l'hyperparamètre `comparator_list`. Le vecteur assemblé transmet ensuite via une couche perceptron multicouche (MLP), qui produit une sortie que la fonction de perte compare aux étiquettes que vous avez fournies. Cette comparaison évalue la force de la relation entre les objets dans la paire comme prévu par le modèle. Le schéma suivant montre ce flux de travail.
![\[Architecture de l'algorithme Object2Vec des entrées de données aux scores\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/object2vec-training-image.png)
## Étape 3 : Produire les inférences
Une fois que le modèle est entraîné, vous pouvez utiliser l'encodeur entraîné pour prétraiter les objets d'entrée ou pour exécuter les deux types d'inférence :
+ Pour convertir les objets d'entrée singleton en intégrations de longueur fixe à l'aide de l'encodeur correspondant
+ Pour prédire l'étiquette ou le score de relation entre une paire d'objets d'entrée
Le serveur d'inférence calcule automatiquement lequel des deux modes est demandé en fonction des données d'entrée. Pour obtenir les intégrations comme sortie, fournissez une seule entrée dans chaque instance. Pour prédire l'étiquette ou le score de relation, fournissez deux entrées dans la paire.
# Hyperparamètres Object2Vec
Dans la demande `CreateTrainingJob`, vous spécifiez l'algorithme d'entraînement. Vous pouvez également spécifier des hyperparamètres spécifiques à l'algorithme sous forme de cartes. string-to-string Le tableau suivant répertorie les hyperparamètres de l'algorithme d'entraînement Object2Vec.
| Nom du paramètre | Description |
| --- | --- |
| enc0\$1max\$1seq\$1len | Longueur maximale de la séquence pour l'encodeur enc0. **Obligatoire** Valeurs valides : 1 ≤ entier ≤ 5 000 |
| enc0\$1vocab\$1size | Taille du vocabulaire des jetons enc0. **Obligatoire** Valeurs valides : 2 ≤ entier ≤ 3 000 000 |
| bucket\$1width | Différence autorisée entre les longueurs de séquence de données lorsque la mise en compartiment est activée. Pour activer la mise en compartiment, spécifiez une valeur différente de zéro pour ce paramètre. **Facultatif** Valeurs valides : 0 ≤ entier ≤ 100 Valeur par défaut : 0 (pas de mise en compartiment) |
| comparator\$1list | Une liste utilisée pour personnaliser la manière dont deux imbrications sont comparées. La couche de l'opérateur de comparaison Object2Vec prend les encodages des deux encodeurs en tant qu'entrées et donne un seul vecteur. Ce vecteur est une concaténation de sous-vecteurs. Les valeurs de chaîne transmises à l'action `comparator_list` et l'ordre dans lequel elles sont transmises déterminent la façon dont ces sous-vecteurs sont assemblés. Par exemple, si `comparator_list="hadamard, concat"`, l'opérateur de comparaison crée le vecteur en concaténant le produit Hadamard de deux encodages et la concaténation de deux encodages. Si, d'un autre côté, `comparator_list="hadamard"`, puis l'opérateur de comparaison crée le vecteur en tant que produit hadamard de deux encodages seulement. **Facultatif** Valeurs valides : une chaîne qui contient une combinaison des noms des trois opérateurs binaires : `hadamard`, `concat` ou `abs_diff`. L'algorithme Object2Vec requiert actuellement que les deux encodages de vecteur aient la même dimension. Ces opérateurs produisent les sous-vecteurs comme suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/object2vec-hyperparameters.html) Valeur par défaut : `"hadamard, concat, abs_diff"` |
| dropout | Probabilité de dropout pour les couches réseau. Le *dropout* est une forme de régularisation utilisée dans les réseaux neuronaux qui réduit le surajustement en tronquant les neurones codépendants. **Facultatif** Valeurs valides : 0.0 ≤ valeur flottante ≤ 1.0 Valeur par défaut : 0.0 |
| early\$1stopping\$1patience | Nombre de périodes (epoch) consécutives sans amélioration autorisée avant l'application d'un arrêt anticipé. Une amélioration est définie par l'hyperparamètre `early_stopping_tolerance`. **Facultatif** Valeurs valides : 1 ≤ entier ≤ 5 Valeur par défaut : 3 |
| early\$1stopping\$1tolerance | La réduction de la fonction de perte qu'un algorithme doit atteindre entre des epochs qui se suivent pour éviter l'arrêt précoce après le nombre d'epochs qui se suivent spécifié dans les conclusions de l'hyperparamètre `early_stopping_patience`. **Facultatif** Valeurs valides : 0.000001 ≤ valeur flottante ≤ 0.1 Valeur par défaut : 0.01 |
| enc\$1dim | Dimension de la sortie de la couche d'intégration. **Facultatif** Valeurs valides : 4 ≤ entier ≤ 10 000 Valeur par défaut : 4096 |
| enc0\$1network | Modèle réseau de l'encodeur enc0. **Facultatif** Valeurs valides : `hcnn`, `bilstm` ou `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/object2vec-hyperparameters.html) Valeur par défaut : `hcnn` |
| enc0\$1cnn\$1filter\$1width | La largeur de filtre de l'encodeur enc0 du réseau neuronal convolutif (CNN). **Conditionnel** Valeurs valides : 1 ≤ entier ≤ 9 Valeur par défaut : 3 |
| enc0\$1freeze\$1pretrained\$1embedding | Indique s'il faut bloquer les pondérations des intégrations préentraînées enc0. **Conditionnel** Valeurs valides : `True` ou `False` Valeur par défaut : `True` |
| enc0\$1layers | Nombre de couches de l'encodeur enc0. **Conditionnel** Valeurs valides : `auto` ou 1 ≤ entier ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/object2vec-hyperparameters.html) Valeur par défaut : `auto` |
| enc0\$1pretrained\$1embedding\$1file | Nom de fichier du fichier des intégrations de jetons enc0 préentraînés du canal de données auxiliaires. **Conditionnel** Valeurs valides : chaîne avec des caractères alphanumériques, tiret de soulignement (\$1) ou point (.). [A-Za-z0-9\$1.\$1\$1] Valeur par défaut : "" (chaîne vide) |
| enc0\$1token\$1embedding\$1dim | Dimension de la sortie de la couche d'intégration des jetons enc0. **Conditionnel** Valeurs valides : 2 ≤ entier ≤ 1 000 Valeur par défaut : 300 |
| enc0\$1vocab\$1file | Le fichier de vocabulaire permettant de mapper des vecteurs d'intégration de jetons enc0 préentraînés au vocabulaire numérique. IDs **Conditionnel** Valeurs valides : chaîne avec des caractères alphanumériques, tiret de soulignement (\$1) ou point (.). [A-Za-z0-9\$1.\$1\$1] Valeur par défaut : "" (chaîne vide) |
| enc1\$1network | Modèle réseau de l'encodeur enc1. Si vous voulez que l'encodeur enc1 utilise le même modèle de réseau qu'enc0, y compris les valeurs des hyperparamètres, définissez la valeur sur `enc0`. Même lorsque les réseaux d'encodeur enc1 et enc0 ont des architectures symétriques, vous ne pouvez pas partager les valeurs des paramètres pour ces réseaux. **Facultatif** Valeurs valides : `enc0`, `hcnn`, `bilstm` ou `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/object2vec-hyperparameters.html) Valeur par défaut : `enc0` |
| enc1\$1cnn\$1filter\$1width | Largeur de filtre de l'encodeur enc1 CNN. **Conditionnel** Valeurs valides : 1 ≤ entier ≤ 9 Valeur par défaut : 3 |
| enc1\$1freeze\$1pretrained\$1embedding | Indique s'il faut bloquer les pondérations des intégrations préentraînées enc1. **Conditionnel** Valeurs valides : `True` ou `False` Valeur par défaut : `True` |
| enc1\$1layers | Nombre de couches de l'encodeur enc1. **Conditionnel** Valeurs valides : `auto` ou 1 ≤ entier ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/object2vec-hyperparameters.html) Valeur par défaut : `auto` |
| enc1\$1max\$1seq\$1len | Longueur maximale de la séquence pour l'encodeur enc1. **Conditionnel** Valeurs valides : 1 ≤ entier ≤ 5 000 |
| enc1\$1pretrained\$1embedding\$1file | Nom de fichier du fichier des intégrations de jetons enc1 préentraînés du canal de données auxiliaires. **Conditionnel** Valeurs valides : chaîne avec des caractères alphanumériques, tiret de soulignement (\$1) ou point (.). [A-Za-z0-9\$1.\$1\$1] Valeur par défaut : "" (chaîne vide) |
| enc1\$1token\$1embedding\$1dim | Dimension de la sortie de la couche d'intégration des jetons enc1. **Conditionnel** Valeurs valides : 2 ≤ entier ≤ 1 000 Valeur par défaut : 300 |
| enc1\$1vocab\$1file | Le fichier de vocabulaire permettant de mapper les intégrations de jetons enc1 préentraînés au vocabulaire. IDs **Conditionnel** Valeurs valides : chaîne avec des caractères alphanumériques, tiret de soulignement (\$1) ou point (.). [A-Za-z0-9\$1.\$1\$1] Valeur par défaut : "" (chaîne vide) |
| enc1\$1vocab\$1size | Taille du vocabulaire des jetons enc0. **Conditionnel** Valeurs valides : 2 ≤ entier ≤ 3 000 000 |
| epochs | Nombre de périodes (epoch) à exécuter pour l'entraînement. **Facultatif** Valeurs valides : 1 ≤ entier ≤ 100 Valeur par défaut : 30 |
| learning\$1rate | Taux d'apprentissage pour l'entraînement. **Facultatif** Valeurs valides : 1.0E-6 ≤ valeur flottante ≤ 1.0 Valeur par défaut : 0.0004 |
| mini\$1batch\$1size | Taille du lot en laquelle l'ensemble de données est scindé pour un `optimizer` au cours de l'entraînement. **Facultatif** Valeurs valides : 1 ≤ entier ≤ 10 000 Valeur par défaut : 32 |
| mlp\$1activation | Type de la fonction d'activation de la couche MLP (multilayer perceptron). **Facultatif** Valeurs valides : `tanh`, `relu` ou `linear` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/object2vec-hyperparameters.html) Valeur par défaut : `linear` |
| mlp\$1dim | La dimension de la sortie de SCS des couches. **Facultatif** Valeurs valides : 2 ≤ entier ≤ 10 000 Valeur par défaut : 512 |
| mlp\$1layers | Le nombre de couches SCS dans le réseau. **Facultatif** Valeurs valides : 0 ≤ entier ≤ 10 Valeur par défaut : 2 |
| negative\$1sampling\$1rate | Le ratio des exemples négatifs générés pour faciliter l'algorithme d'entraînement, par rapport aux exemples positifs qui sont fournis par les utilisateurs. Les exemples négatifs représentent les données qui sont peu probables dans la réalité et sont étiquetées négativement pour l'entraînement. Ils facilitent l'entraînement d'un modèle pour faire la distinction entre les exemples positifs et les exemples négatifs observés qui ne le sont pas. Pour spécifier le ratio des exemples négatifs par rapport aux exemples positifs utilisés pour l'entraînement, définissez la valeur sur un nombre entier positif. Par exemple, si vous entraînez l'algorithme sur les données d'entrée dans lequel tous les exemples sont positifs et si vous définissez `negative_sampling_rate` sur 2, l'algorithme Object2Vec génère en interne deux exemples négatifs par exemple positif. Si vous ne souhaitez pas générer ou utiliser des exemples négatifs au cours de l'entraînement, définissez la valeur sur 0. **Facultatif** Valeurs valides : 0 ≤ entier Valeur par défaut : 0 (désactivé) |
| num\$1classes | Nombre de classes pour la formation de la classification. Amazon SageMaker AI ignore cet hyperparamètre pour les problèmes de régression. **Facultatif** Valeurs valides : 2 ≤ entier ≤ 30 Valeur par défaut : 2 |
| optimizer | Type d'optimiseur. **Facultatif** Valeurs valides : `adadelta`, `adagrad`, `adam`, `sgd` ou `rmsprop`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/object2vec-hyperparameters.html) Valeur par défaut : `adam` |
| output\$1layer | Type de la couche de sortie dans laquelle vous spécifiez que la tâche est une régression ou une classification. **Facultatif** Valeurs valides : `softmax` ou `mean_squared_error` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/object2vec-hyperparameters.html) Valeur par défaut : `softmax` |
| tied\$1token\$1embedding\$1weight | Définit s'il convient d'utiliser une couche d'incorporation partagée pour les deux encodeurs. Si les entrées pour les deux encodeurs utilisent le même jeton au niveau des unités, utilisez un jeton partagé ou intégrez une couche. Par exemple, pour un ensemble de documents, si un encodeur encode des phrases et qu'un autre encode tous les documents, vous pouvez utiliser un jeton partagé ou intégrer une couche. En effet, les deux phrases et les documents sont composés de jetons à partir du même vocabulaire. **Facultatif** Valeurs valides : `True` ou `False` Valeur par défaut : `False` |
| token\$1embedding\$1storage\$1type | Le mode de mise à jour de dégradé utilisé au cours de l'entraînement : lorsque le mode `dense` est utilisé, l'optimiseur calcule l'intégralité de la matrice de dégradé pour le jeton ou intègre une couche, même si la plupart des lignes du dégradé ont une valeur nulle. Lorsque le mode `sparse` est utilisé, l'optimiseur stocke uniquement les lignes du dégradé qui sont en fait utilisées dans le lot. Si vous voulez que l'algorithme effectue des mises à jour de dégradé paresseux, qui calculent les dégradés uniquement dans les lignes différentes de zéro et accélèrent l'entraînement, spécifiez `row_sparse`. La définition de la valeur sur `row_sparse` limite les valeurs disponibles pour d'autres hyperparamètres, comme suit : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/object2vec-hyperparameters.html) **Facultatif** Valeurs valides : `dense` ou `row_sparse` Valeur par défaut : `dense` |
| weight\$1decay | Paramètre de dégradation de pondération utilisé pour l'optimisation. **Facultatif** Valeurs valides : 0 ≤ valeur flottante ≤ 10 000 Valeur par défaut : 0 (aucune dégradation) |
# Régler un modèle Object2Vec
Le *réglage de modèle automatique*, ou réglage d'hyperparamètre, détecte la meilleure version d'un modèle en exécutant plusieurs tâches qui testent une plage d'hyperparamètres sur votre jeu de données. Vous choisissez les hyperparamètres réglables, une plage de valeurs pour chacun d'eux et une métrique d'objectif. Pour la métrique objective, vous utilisez l'une des métriques que l'algorithme calcule. Le réglage de modèle automatique recherche les hyperparamètres choisis pour trouver la combinaison des valeurs qui résultent dans le modèle optimisant la métrique d'objectif.
Pour plus d'informations sur le réglage de modèle, consultez [Réglage automatique du modèle grâce à l' SageMaker IA](automatic-model-tuning.md).
## Métriques calculées par l'algorithme Object2Vec
L'algorithme Object2Vec comporte à la fois des métriques de classification et des métriques de régression. Le type `output_layer` détermine la métrique que vous pouvez utiliser pour le réglage de modèle automatique.
### Métriques de régression calculées par l'algorithme Object2Vec
L'algorithme indique une métrique d'erreur quadratique moyenne pour la régression, calculée pendant les tests et la validation. Lors du réglage du modèle pour les tâches de régression, choisissez cette métrique comme objectif.
| Nom de la métrique | Description | Orientation de l'optimisation |
| --- | --- | --- |
| test:mean\$1squared\$1error | Erreur quadratique moyenne (RMSE) | Réduire |
| validation:mean\$1squared\$1error | Erreur quadratique moyenne (RMSE) | Réduire |
### Métriques de classification calculées par l'algorithme Object2Vec
L'algorithme Object2Vec rapporte les métriques de classification de précision et d'entropie croisée, calculées pendant les tests et la validation. Lors du réglage du modèle pour les tâches de classification, choisissez l'une d'elles comme objectif.
| Nom de la métrique | Description | Orientation de l'optimisation |
| --- | --- | --- |
| test:accuracy | Précision | Agrandir |
| test:cross\$1entropy | Entropie croisée | Réduire |
| validation:accuracy | Précision | Agrandir |
| validation:cross\$1entropy | Entropie croisée | Réduire |
## Hyper-paramètres Object2Vec réglables
Vous pouvez ajuster les hyperparamètres suivants pour l'algorithme Object2Vec.
| Nom de l'hyperparamètre | Type de l'hyperparamètre | Plages et valeurs recommandées |
| --- | --- | --- |
| dropout | ContinuousParameterRange | MinValue: 0,0, MaxValue 1,0 |
| 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 |
# Format de données pour l'entraînement d'Object2Vec
Lors d’un entraînement avec l’algorithme Object2Vec, assurez-vous que les données d’entrée de votre demande sont au format JSON Lines, où chaque ligne représente un point de données unique.
## Entrée : format de demande JSON Lines
Type de contenu : 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]}
```
« in0 » et « in1 » sont les entrées d'encoder0 et d'encoder1, respectivement. Le même format est valide pour les problèmes de régression et les problèmes de classification. Pour la régression, le champ `"label"` peut accepter les valeurs réelles des entrées.
# Format de données pour l'inférence d'Object2Vec
La page suivante décrit les formats de demande d'entrée et de réponse de sortie permettant d'obtenir une inférence de notation à partir du modèle Amazon SageMaker AI Object2Vec.
## Optimisation du GPU : classification ou régression
La mémoire GPU étant faible, la variable d'environnement `INFERENCE_PREFERRED_MODE` peut être spécifiée pour déterminer si la classification/régression ou le réseau d'inférence [Sortie : intégrations de l'encodeur](object2vec-encoder-embeddings.md#object2vec-out-encoder-embeddings-data) doit être chargé dans le GPU. Si la majeure partie de votre inférence est destinée à la classification ou la régression, spécifiez `INFERENCE_PREFERRED_MODE=classification`. Voici un exemple de transformation par lots utilisant 4 instances de p3.2xlarge qui optimisent l'inférence : 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)
```
## Entrée : format de demande de classification ou de régression
Content-type : 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]}
]
}
```
Type de contenu : 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]}
```
Pour les problèmes de classification, la longueur du vecteur des scores correspond à `num_classes`. Pour les problèmes de régression, la longueur est égale à 1.
## Sortie : format de réponse de classification ou de régression
ACCEPT : application/json.
```
{
"predictions": [
{
"scores": [
0.6533935070037842,
0.07582679390907288,
0.2707797586917877
]
},
{
"scores": [
0.026291321963071823,
0.6577019095420837,
0.31600672006607056
]
}
]
}
```
ACCEPT: application/jsonlines.
```
{"scores":[0.195667684078216,0.395351558923721,0.408980727195739]}
{"scores":[0.251988261938095,0.258233487606048,0.489778339862823]}
{"scores":[0.280087798833847,0.368331134319305,0.351581096649169]}
```
Dans les formats de régression et de classification, les scores s'appliquent à chaque étiquette.
# Intégrations de l'encodeur pour Object2Vec
La page suivante répertorie les formats de demande d'entrée et de réponse de sortie permettant d'obtenir l'inférence d'intégration d'un encodeur à partir du modèle Amazon SageMaker AI Object2Vec.
## Optimisation du GPU : intégrations de l'encodeur
Une intégration est un mappage d'objets discrets, tels que des mots, sur des vecteurs de nombres réels.
La mémoire GPU étant faible, la variable d'environnement `INFERENCE_PREFERRED_MODE` peut être spécifiée pour déterminer si les [Format de données pour l'inférence d'Object2Vec](object2vec-inference-formats.md) ou le réseau d'inférence d'intégration de l'encodeur doit être chargé dans le GPU. Si la majeure partie de votre inférence est destinée aux intégrations de l'encodeur, spécifiez `INFERENCE_PREFERRED_MODE=embedding`. Voici un exemple Batch Transform d'utilisation de 4 instances p3.2xlarge optimisé pour l'inférence d'intégration de l'encodeur :
```
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)
```
## Entrée : intégrations de l'encodeur
Content-type: application/json; infer\$1max\$1seqlens=,
Où et sont des entiers inclus dans la plage [1 5000] qui définissent les longueurs de séquence maximales pour l'encodeur avant et arrière.
```
{
"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]}
]
}
```
Content-type: application/jsonlines; infer\$1max\$1seqlens=,
Où et sont des entiers inclus dans la plage [1 5000] qui définissent les longueurs de séquence maximales pour l'encodeur avant et arrière.
```
{"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]}
```
Dans ces deux formats, vous spécifiez un seul type d'entrée, `“in0”` ou `“in1.”` Le service d'inférence appelle alors l'encodeur correspondant et génère les intégrations de chacune des instances.
## Sortie : intégrations de l'encodeur
Content-type : 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]}
]
}
```
Type de contenu : 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]}
```
La longueur du vecteur de la sortie des intégrations par le service d'inférence est égale à la valeur de l'un des hyperparamètres, que vous spécifiez au moment de l'entraînement : `enc0_token_embedding_dim`, `enc1_token_embedding_dim` ou `enc_dim`.