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.
# Sequence-to-Sequence Algorithme
Amazon SageMaker AI Sequence to Sequence est un algorithme d'apprentissage supervisé dans lequel l'entrée est une séquence de jetons (par exemple, du texte, du son) et la sortie générée est une autre séquence de jetons. Parmi les applications, citons : la traduction automatique (saisissez une phrase d'une langue et prédisez ce que sera cette phrase dans une autre langue), la synthèse de texte (entrez une chaîne de mots plus longue et prédisez une chaîne de mots plus courte qui constitue un résumé), speech-to-text (clips audio convertis en phrases de sortie sous forme de jetons). Récemment, les problèmes dans ce domaine ont été modélisés avec succès grâce aux réseaux neuronaux profonds qui offrent une amélioration significative des performances par rapport aux méthodologies précédentes. Amazon SageMaker AI seq2seq utilise des modèles de réseaux neuronaux récurrents (RNNs) et de réseaux neuronaux convolutifs (CNN) en accordant une attention particulière aux architectures d'encodeurs-décodeurs.
**Topics**
+ [Interface d'entrée/sortie pour l'algorithme Sequence-to-Sequence](#s2s-inputoutput)
+ [Recommandation d'instance EC2 pour l'algorithme Sequence-to-Sequence](#s2s-instances)
+ [Sequence-to-Sequence Exemples de carnets](#seq-2-seq-sample-notebooks)
+ [Fonctionnement de Sequence-to-Sequence](seq-2-seq-howitworks.md)
+ [Sequence-to-Sequence Hyperparamètres](seq-2-seq-hyperparameters.md)
+ [Régler un Sequence-to-Sequence modèle](seq-2-seq-tuning.md)
## Interface d'entrée/sortie pour l'algorithme Sequence-to-Sequence
**Entrainement**
SageMaker AI seq2seq attend des données au format Recordio-ProtoBuf. Cependant, les jetons doivent être des nombres entiers, et non des nombres flottants, comme c'est habituellement le cas.
[L'exemple de bloc-notes seq2seq](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html) contient un script permettant de convertir les fichiers texte tokenisés au format protobuf. En règle générale, l'algorithme empaquette les données au sein de tenseurs (entiers 32 bits) et génère les fichiers de vocabulaire nécessaires, requis pour le calcul des métriques et pour les inférences.
Une fois le prétraitement terminé, l'algorithme peut être appelée pour la formation. L'algorithme attend trois canaux :
+ `train` : ce canal doit contenir les données de formation (le fichier `train.rec` généré par le script de prétraitement, par exemple).
+ `validation` : ce canal doit contenir les données de validation (le fichier `val.rec` généré par le script de prétraitement, par exemple).
+ `vocab` : doit contenir deux fichiers de vocabulaire (`vocab.src.json` et `vocab.trg.json`)
Si l'algorithme ne trouve pas les données dans l'un de ces trois canaux, la formation se traduit par une erreur.
**Inférence**
Pour les points de terminaison hébergés, l'inférence prend en charge deux formats de données. Pour effectuer l'inférence en utilisant les jetons de texte séparés par un espace, utilisez le format `application/json`. Sinon, choisissez le format `recordio-protobuf` pour utiliser les données codées en nombres entiers. Les deux modes prennent en charge le traitement par lots des données d'entrée. Le format `application/json` vous permet également de visualiser la matrice d'attention.
+ `application/json` : attend l'entrée au format JSON et renvoie la sortie au format JSON. Les types du contenu et de l'acceptation doivent être tous les deux au format `application/json`. Chaque séquence doit se présenter sous forme d'une chaîne avec des jetons séparés par un espace. Ce format est recommandé lorsque le nombre de séquences source du lot est réduit. Il prend également en charge les options de configuration supplémentaires suivantes :
`configuration` : \$1`attention_matrix` : `true`\$1 : renvoie la matrice d'attention de la séquence d'entrée.
+ `application/x-recordio-protobuf` : attend l'entrée au format `recordio-protobuf` et renvoie la sortie au format `recordio-protobuf format`. Les types du contenu et de l'acceptation doivent être tous les deux au format `applications/x-recordio-protobuf`. En ce qui concerne ce format, les séquences source doivent être converties en une liste d'entiers pour les codages protobuf ultérieurs. Ce format est recommandé pour les inférences en bloc.
Pour les transformations par lots, l'inférence prend en charge le format JSON Lines. La transformation par lots attend l'entrée au format JSON Lines et renvoie la sortie au format JSON Lines. Les types du contenu et de l'acceptation doivent être tous les deux au format `application/jsonlines`. Le format d'entrée est le suivant :
```
content-type: application/jsonlines
{"source": "source_sequence_0"}
{"source": "source_sequence_1"}
```
Le format de la réponse est le suivant :
```
accept: application/jsonlines
{"target": "predicted_sequence_0"}
{"target": "predicted_sequence_1"}
```
Pour plus d'informations sur la sérialisation et la désérialisation des entrées et des sorties en formats spécifiques pour l'inférence, consultez [Sequence-to-Sequence Exemples de carnets](#seq-2-seq-sample-notebooks).
## Recommandation d'instance EC2 pour l'algorithme Sequence-to-Sequence
L'algorithme Amazon SageMaker AI seq2seq ne prend en charge que les types d'instances GPU et ne peut s'entraîner que sur une seule machine. Cependant, vous pouvez utiliser des instances avec plusieurs GPUs. L'algorithme seq2seq prend en charge les familles d'instances de GPU P2, P3, G4dn et G5.
## Sequence-to-Sequence Exemples de carnets
Pour un exemple de bloc-notes expliquant comment utiliser l'algorithme SageMaker AI Sequence to Sequence pour entraîner un modèle de traduction anglais-allemand, voir [Exemple de traduction automatique anglais-allemand à l'aide d' SageMaker AI](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html) Seq2Seq. Pour savoir comment créer et accéder à des instances de bloc-notes Jupyter que vous pouvez utiliser pour exécuter l'exemple dans SageMaker AI, consultez. [Instances de SageMaker blocs-notes Amazon](nbi.md) Une fois que vous avez créé une instance de bloc-notes et que vous l'avez ouverte, sélectionnez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. Les exemples de blocs-notes de modélisation de rubrique utilisant les algorithmes NTM se trouvent dans la section **Introduction to Amazon algorithms** (Présentation des algorithmes Amazon). Pour ouvrir un bloc-notes, cliquez sur son onglet **Use (Utiliser)** et sélectionnez **Create copy (Créer une copie)**.
# Fonctionnement de Sequence-to-Sequence
Généralement, un réseau neuronal destiné à la sequence-to-sequence modélisation se compose de quelques couches, notamment :
+ **Couche d'intégration**. Dans cette couche, la matrice d'entrée, qui correspond aux jetons d'entrée codés de façon fragmentée (codage à chaud, par exemple), est associée à une couche de fonctions dense. Cela est nécessaire car un vecteur de caractéristiques de grande dimension est plus capable de coder des informations concernant un jeton particulier (corpus de texte pour mot) qu'un simple one-hot-encoded vecteur. Il est également courant d'initialiser cette couche d'intégration avec un vecteur de mots préentraîné tel que [Glove [FastText](https://fasttext.cc/)](https://nlp.stanford.edu/projects/glove/)ou de l'initialiser de manière aléatoire et d'en apprendre les paramètres pendant l'entraînement.
+ **Couche d'encodeur**. Une fois que les jetons d'entrée ont été associés à un espace de fonctions haute dimension, la séquence est transmise via une couche encodeur pour compresser l'ensemble des informations de la couche d'intégration en entrée (de la totalité de la séquence) en un vecteur de fonction de longueur fixe. En règle générale, un encodeur se compose de réseaux de type RNN comme les réseaux LSTM (Long Short-Term Memory) ou GRU (Gated Recurrent Units). (Le [ blog Colah](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) explique les réseaux LSTM de façon détaillée.)
+ **Couche de décodeur**. La couche décodeur accepte le vecteur de fonction codé et génère en sortie la séquence de jetons. Généralement, cette couche est également conçue avec les architectures RNN (LSTM et GRU).
La totalité du modèle est formée conjointement pour optimiser la probabilité de la séquence cible en fonction de la séquence source. Ce modèle a été présenté pour la première fois par [Sutskever et autres](https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf) en 2014.
**Mécanisme d'attention**. L'inconvénient d'une architecture encodeur/décodeur est que les performances du modèle diminuent au fur et à mesure que la longueur de la séquence source augmente : la raison en est la limite de la quantité d'informations que le vecteur de fonction codé de longueur fixe peut contenir. Pour résoudre ce problème, en 2015, Bahdanau et al. ont proposé le [mécanisme d'attention](https://arxiv.org/pdf/1409.0473.pdf). Dans un tel mécanisme, le décodeur tente de trouver l'emplacement dans la séquence de l'encodeur où peuvent se trouver les informations les plus importantes, puis utilise celles-ci et les mots précédemment décodés pour prédire le jeton suivant de la séquence.
Pour plus de détails, reportez-vous au livre blanc [Effective Approaches to Attention-based Neural Machine Translation](https://arxiv.org/abs/1508.04025) par Luong, et al. qui explique et simplifie les calculs des différents mécanismes d'attention. En outre, le livre blanc [Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation](https://arxiv.org/abs/1609.08144) par Wu, et al. décrit l'architecture de Google pour la traduction automatique, qui utilise les connexions skip entre les couches encodeur et décodeur.
# Sequence-to-Sequence Hyperparamètres
Le tableau suivant répertorie les hyperparamètres que vous pouvez définir lors de l'entraînement avec l'algorithme Amazon SageMaker AI Sequence-to-Sequence (seq2seq).
| Nom du paramètre | Description |
| --- | --- |
| batch\$1size | Taille de lot minimale pour une pente de gradient. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 64 |
| beam\$1size | Longueur du faisceau pour la recherche de faisceau. Utilisé lors de la formation pour le calcul de `bleu` et utilisé lors de l'inférence. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 5 |
| bleu\$1sample\$1size | Nombre d’instances à choisir dans le jeu de données de validation pour décoder et calculer le score de `bleu` durant l’entraînement. À définir sur -1 pour utiliser l'ensemble complet de validation (si `bleu` a la valeur `optimized_metric`). **Facultatif** Valeurs valides : nombre entier Valeur par défaut : 0 |
| bucket\$1width | Renvoie les compartiments (source, cible) jusqu'à (`max_seq_len_source`, `max_seq_len_target`). Le côté le plus long des données utilise des étapes de `bucket_width` tandis que le côté le plus court utilise des étapes réduites en fonction du ratio de target/source longueur moyen. Si l'un des côtés atteint sa longueur maximale avant l'autre, la largeur des compartiments supplémentaires de ce côté-là est fixée à ce côté-là de `max_len`. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 10 |
| bucketing\$1enabled | À définir sur `false` pour désactiver la mise en compartiment, puis déployez jusqu'à la longueur maximale. **Facultatif** Valeurs valides : `true` ou `false` Valeur par défaut : `true` |
| checkpoint\$1frequency\$1num\$1batches | Contrôle et évaluation tous les x lots. Cet hyperparamètre de point de contrôle est transmis à l'algorithme seq2seq de l' SageMaker IA pour arrêter rapidement et récupérer le meilleur modèle. Le point de contrôle de l'algorithme s'exécute localement dans le conteneur d'entraînement de l'algorithme et n'est pas compatible avec le point de contrôle basé sur l' SageMaker IA. L'algorithme enregistre temporairement les points de contrôle dans un chemin local et stocke l'artefact du meilleur modèle dans le chemin de sortie du modèle dans S3 après l'arrêt de la tâche d'entraînement. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 1000 |
| checkpoint\$1threshold | Nombre maximal du modèle de points de contrôle autorisé à ne pas être amélioré dans `optimized_metric` de jeu de données de validation avant l’arrêt de l’entraînement. Cet hyperparamètre de point de contrôle est transmis à l'algorithme seq2seq de l' SageMaker IA pour arrêter rapidement et récupérer le meilleur modèle. Le point de contrôle de l'algorithme s'exécute localement dans le conteneur d'entraînement de l'algorithme et n'est pas compatible avec le point de contrôle basé sur l' SageMaker IA. L'algorithme enregistre temporairement les points de contrôle dans un chemin local et stocke l'artefact du meilleur modèle dans le chemin de sortie du modèle dans S3 après l'arrêt de la tâche d'entraînement. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 3 |
| clip\$1gradient | Rognez les valeurs de gradient absolu supérieures à celle-ci. Définissez une valeur négative pour désactiver. **Facultatif** Valeurs valides : float Valeur par défaut : 1 |
| cnn\$1activation\$1type | Type d'activation `cnn` à utiliser. **Facultatif** Valeurs valides : string. L'une des valeurs suivantes : `glu`, `relu`, `softrelu`, `sigmoid` ou `tanh`. Valeur par défaut : `glu` |
| cnn\$1hidden\$1dropout | Probabilité de dropout entre couches convolutives. **Facultatif** Valeurs valides : float. Plage [0,1]. Valeur par défaut : 0 |
| cnn\$1kernel\$1width\$1decoder | Largeur du noyau (kernel) pour le décodeur `cnn`. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 5 |
| cnn\$1kernel\$1width\$1encoder | Largeur du noyau (kernel) pour l'encodeur `cnn`. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 3 |
| cnn\$1num\$1hidden | Nombre d'unités `cnn` masquées de l'encodeur et du décodeur. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 512 |
| decoder\$1type | Type de décodeur. **Facultatif** Valeurs valides : string. `rnn` ou `cnn`. Valeur par défaut : *rnn* |
| embed\$1dropout\$1source | Probabilité de dropout pour les intégrations côté source. **Facultatif** Valeurs valides : float. Plage [0,1]. Valeur par défaut : 0 |
| embed\$1dropout\$1target | Probabilité de dropout pour les intégrations côté cible. **Facultatif** Valeurs valides : float. Plage [0,1]. Valeur par défaut : 0 |
| encoder\$1type | Type d'encodeur. L'architecture des `rnn` est basée sur le mécanisme d'attention de Bahdanau et al. Celle des réseaux *cnn* repose sur Gehring et al. **Facultatif** Valeurs valides : string. `rnn` ou `cnn`. Valeur par défaut : `rnn` |
| fixed\$1rate\$1lr\$1half\$1life | Moitié de vie pour le taux d'apprentissage en termes de nombre de points de contrôle des planificateurs `fixed_rate_`\$1. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 10 |
| learning\$1rate | Taux de formation initial. **Facultatif** Valeurs valides : float Valeur par défaut : 0.0003 |
| loss\$1type | Fonction de perte pour la formation. **Facultatif** Valeurs valides : String. `cross-entropy` Valeur par défaut : `cross-entropy` |
| lr\$1scheduler\$1type | Type de planificateur du taux d'apprentissage. `plateau_reduce` signifie une réduction du taux d'apprentissage à chaque fois que `optimized_metric` sur des niveaux`validation_accuracy`. `inv_t` est la dégradation temporelle inverse `learning_rate`/(1\$1`decay_rate`\$1 t) **Facultatif** Valeurs valides : string. `plateau_reduce`, `fixed_rate_inv_t` ou `fixed_rate_inv_sqrt_t`. Valeur par défaut : `plateau_reduce` |
| max\$1num\$1batches | Nombre maximum de updates/batches à traiter. -1 pour un nombre infini. **Facultatif** Valeurs valides : nombre entier Valeur par défaut : -1 |
| max\$1num\$1epochs | Nombre maximal de dates epoch à transmettre par le biais des données de formation avant que l'ajustement ne soit arrêté. La formation se poursuit jusqu'au nombre de dates epoch, même si la précision de la validation n'est pas améliorée lorsque ce paramètre est transmis. Paramètre ignoré s'il n'est pas passé. **Facultatif** Valeurs valides : nombre entier positif et inférieur ou égal à max\$1num\$1epochs. Valeur par défaut : none |
| max\$1seq\$1len\$1source | Longueur maximale de la séquence source. Les séquences qui dépassent cette longueur sont tronquées à cette valeur. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 100 |
| max\$1seq\$1len\$1target | Longueur maximale de la séquence cible. Les séquences qui dépassent cette longueur sont tronquées à cette valeur. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 100 |
| min\$1num\$1epochs | Nombre minimal de périodes (epochs) que la formation doit exécuter avant qu'elle ne soit arrêtée via les conditions `early_stopping`. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 0 |
| momentum | Constante de vitesse utilisée pour `sgd`. Ne transmettez pas ce paramètre si vous utilisez `adam` ou `rmsprop`. **Facultatif** Valeurs valides : float Valeur par défaut : none |
| num\$1embed\$1source | Taille d'intégration des jetons source. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 512 |
| num\$1embed\$1target | Taille d'intégration des jetons cible. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 512 |
| num\$1layers\$1decoder | Nombre de couches du décodeur *rnn* ou *cnn*. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 1 |
| num\$1layers\$1encoder | Nombre de couches de l'encodeur `rnn` ou `cnn`. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 1 |
| optimized\$1metric | Métriques d'optimisation avec arrêt anticipé. **Facultatif** Valeurs valides : string. `perplexity`, `accuracy` ou `bleu`. Valeur par défaut : `perplexity` |
| optimizer\$1type | Optimiseur à partir duquel choisir. **Facultatif** Valeurs valides : string. `adam`, `sgd` ou `rmsprop`. Valeur par défaut : `adam` |
| plateau\$1reduce\$1lr\$1factor | Facteur avec lequel multiplier le taux d'apprentissage (pour `plateau_reduce`). **Facultatif** Valeurs valides : float Valeur par défaut : 0.5 |
| plateau\$1reduce\$1lr\$1threshold | Pour le planificateur `plateau_reduce`, multipliez le taux d'apprentissage avec le facteur de réduction si la valeur `optimized_metric` ne s'est pas améliorée pour autant de points de contrôle. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 3 |
| rnn\$1attention\$1in\$1upper\$1layers | Transmettez l'attention aux couches supérieures de *rnn*, comme l'article sur le système NMT de Google. Applicable uniquement si plusieurs couches sont utilisées. **Facultatif** Valeurs valides : booléennes (`true` ou `false`) Valeur par défaut : `true` |
| rnn\$1attention\$1num\$1hidden | Nombre d'unités masquées pour les couches d'attention. Valeur par défaut : `rnn_num_hidden` **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : `rnn_num_hidden` |
| rnn\$1attention\$1type | Modèle d'attention pour les encodeurs. `mlp` fait référence à la concaténation (« concat ») et bilinear (bilinéaire) à « general » (voir article de Luong et al.). **Facultatif** Valeurs valides : string. L'une des valeurs suivantes : `dot`, `fixed`, `mlp` ou `bilinear`. Valeur par défaut : `mlp` |
| rnn\$1cell\$1type | Type spécifique d'architecture `rnn`. **Facultatif** Valeurs valides : string. `lstm` ou `gru`. Valeur par défaut : `lstm` |
| rnn\$1decoder\$1state\$1init | Procédure pour initialiser les états du décodeur `rnn` à partir des encodeurs. **Facultatif** Valeurs valides : string. `last`, `avg` ou `zero`. Valeur par défaut : `last` |
| rnn\$1first\$1residual\$1layer | Première couche *rnn* à avoir une connexion résiduelle ; applicable uniquement si le nombre de couches de l'encodeur ou du décodeur est supérieur à 1. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 2 |
| rnn\$1num\$1hidden | Nombre d'unités *rnn* masquées de l'encodeur et du décodeur. La valeur doit être un multiple de 2, car l'algorithme utilise par défaut le réseau LSTM bidirectionnel. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 1024 |
| rnn\$1residual\$1connections | Ajout d'une connexion résiduelle aux types *rnn* empilés. Le nombre de couches doit être supérieur à 1. **Facultatif** Valeurs valides : booléennes (`true` ou `false`) Valeur par défaut : `false` |
| rnn\$1decoder\$1hidden\$1dropout | Probabilité de dropout d'un état masqué qui associe le contexte à l'état *rnn* masqué du décodeur. **Facultatif** Valeurs valides : float. Plage [0,1]. Valeur par défaut : 0 |
| training\$1metric | Métriques de suivi de la formation sur les données de validation. **Facultatif** Valeurs valides : string. `perplexity` ou `accuracy`. Valeur par défaut : `perplexity` |
| weight\$1decay | Constante de dégradation de pondération. **Facultatif** Valeurs valides : float Valeur par défaut : 0 |
| weight\$1init\$1scale | Échelle d'initialisation de pondération (pour les initialisations `uniform` et `xavier`). **Facultatif** Valeurs valides : float Valeur par défaut : 2.34 |
| weight\$1init\$1type | Type d'initialisation de pondération. **Facultatif** Valeurs valides : string. `uniform` ou `xavier`. Valeur par défaut : `xavier` |
| xavier\$1factor\$1type | Type de facteur xavier. **Facultatif** Valeurs valides : string. `in`, `out` ou `avg`. Valeur par défaut : `in` |
# Régler un Sequence-to-Sequence modèle
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. Vous choisissez la métrique d'objectif parmi les métriques que calcule l'algorithme. Le réglage de modèle automatique recherche parmi les hyperparamètres choisis la combinaison de valeurs qui produira un modèle permettant d'optimiser 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' Sequence-to-Sequencealgorithme
L'algorithme seq2seq rapporte trois métriques qui sont calculées au cours de la formation. Choisissez l'une d'entre elles en tant qu'objectif à optimiser lors du réglage des valeurs des hyperparamètres.
| Nom de la métrique | Description | Orientation de l'optimisation |
| --- | --- | --- |
| validation:accuracy | Précision calculée sur le jeu de données de validation. | Agrandir |
| validation:bleu | [Bleu](https://en.wikipedia.org/wiki/BLEU) Score calculé sur le jeu de données de validation. Comme le calcul de BLEU est onéreux, vous pouvez choisir de calculer BLEU sur un sous-échantillon aléatoire de jeu de données de validation pour accélérer le processus global d’entraînement. Utilisez le paramètre `bleu_sample_size` pour spécifier le sous-échantillon. | Agrandir |
| validation:perplexity | [Perplexity](https://en.wikipedia.org/wiki/Perplexity), fonction perte calculée sur le jeu de données de validation. Perplexity mesure l'entropie croisée entre un échantillon empirique et la distribution prédite par un modèle. La fonction fournit ainsi une mesure de la façon dont un modèle prédit les exemples de valeurs. Les modèles adaptés à la prédiction d'un échantillon ont une perplexité faible. | Réduire |
## Hyperparamètres réglables Sequence-to-Sequence
Vous pouvez régler les hyperparamètres suivants pour l'algorithme SageMaker AI Sequence to Sequence. Les hyperparamètres ayant le plus d'impact sur les métriques d'objectif de seq2seq sont : `batch_size`, `optimizer_type`, `learning_rate`, `num_layers_encoder` et `num_layers_decoder`.
| Nom du paramètre | Type de paramètre | Plages recommandées |
| --- | --- | --- |
| 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 | Pour le type xavier : MinValue : 2.0, MaxValue : 3.0 Pour le type uniforme : MinValue : -1.0, MaxValue : 1.0 |
| learning\$1rate | ContinuousParameterRange | MinValue: 0,00005, MaxValue : 0,2 |
| 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 | Applicable uniquement aux réseaux neuronaux récurrents (RNNs). [128,256,512,1024,2048] |
| cnn\$1num\$1hidden | CategoricalParameterRange | Applicable uniquement aux réseaux neuronaux convolutifs ()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, MaxValue 0,5 |
| 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] |