As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Sequence-to-Sequence Algoritimo
O Amazon SageMaker AI Sequence to Sequence é um algoritmo de aprendizado supervisionado em que a entrada é uma sequência de tokens (por exemplo, texto, áudio) e a saída gerada é outra sequência de tokens. Exemplos de aplicativos incluem: tradução automática (insira uma frase de um idioma e preveja qual seria essa frase em outro idioma), resumo de texto (insira uma sequência de palavras mais longa e preveja uma sequência menor de palavras que seja um resumo) speech-to-text (clipes de áudio convertidos em frases de saída em tokens). Recentemente, problemas nesse domínio foram modelados com êxito com redes neurais profundas, que mostram um aumento significativo do desempenho sobre as metodologias anteriores. O Amazon SageMaker AI seq2seq usa modelos de Redes Neurais Recorrentes (RNNs) e Redes Neurais Convolucionais (CNN) com atenção como arquiteturas codificador-decodificadoras.
**Topics**
+ [Interface de entrada/saída para o algoritmo Sequence-to-Sequence](#s2s-inputoutput)
+ [Recomendação de instância do EC2 para o algoritmo Sequence-to-Sequence](#s2s-instances)
+ [Sequence-to-Sequence Exemplos de cadernos](#seq-2-seq-sample-notebooks)
+ [Como o Sequence-to-Sequence funciona](seq-2-seq-howitworks.md)
+ [Sequence-to-Sequence Hiperparâmetros](seq-2-seq-hyperparameters.md)
+ [Ajustar um Sequence-to-Sequence modelo](seq-2-seq-tuning.md)
## Interface de entrada/saída para o algoritmo Sequence-to-Sequence
**Treinamento**
SageMaker O AI seq2seq espera dados no formato Recordio-protobuf. No entanto, os tokens são esperados como números inteiros, e não como pontos flutuantes, como é geralmente o caso.
Um script para converter dados de arquivos de texto indexados para o formato protobuf acompanha o [caderno de exemplo](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html) do seq2seq. Em geral, ele empacota os dados em tensores de inteiros de 32 bits e gera os arquivos de vocabulário necessários para cálculo de métrica e inferência.
Após o pré-processamento, o algoritmo pode ser invocado para treinamento. O algoritmo espera três canais:
+ `train`: deve conter os dados de treinamento (por exemplo, o arquivo `train.rec` gerado pelo script de pré-processamento).
+ `validation`: deve conter os dados de validação (por exemplo, o arquivo `val.rec` gerado pelo script de pré-processamento).
+ `vocab`: deve conter os dois arquivos de vocabulário (`vocab.src.json` e `vocab.trg.json`)
Se o algoritmo não encontrar dados em nenhum desses três canais, o treinamento resultará em um erro.
**Inferência**
Para endpoints hospedados, a inferência oferece apoio para dois formatos de dados. Para executar inferência usando tokens de texto separados por espaço, use o formato `application/json`. Caso contrário, use o formato `recordio-protobuf` para trabalhar com os dados codificados por inteiros. Os dois modos são oferecem apoio ao agrupamento de dados de entrada em lotes. O formato `application/json` também permite que você visualize a matriz de atenção.
+ `application/json`: espera a entrada no formato JSON e retorna a saída no mesmo formato. Os dois cabeçalhos Accept e Content-Type devem ser `application/json`. Cada sequência deve ser uma string com tokens separados por espaço em branco. Esse formato é recomendado quando o número de sequências de origem no lote é pequeno. Também é compatível com as seguintes opções de configuração adicionais:
`configuration`: \$1`attention_matrix`: `true`\$1: retorna a matriz de atenção para a sequência de entrada específica.
+ `application/x-recordio-protobuf`: espera a entrada no formato `recordio-protobuf` e retorna a saída no formato `recordio-protobuf format`. Os dois cabeçalhos Accept e Content-Type devem ser `applications/x-recordio-protobuf`. Para esse formato, as sequências de origem devem ser convertidas em uma lista de inteiros para codificação protobuf subsequente. Esse formato é recomendado para inferência em massa.
Para transformação em lote, a inferência oferece apoio para o formato de linhas JSON. A transformação em lote espera a entrada no formato JSON Lines e retorna a saída no formato de linhas JSON. Os dois cabeçalhos Accept e Content-Type devem ser `application/jsonlines`. O formato da entrada é o seguinte:
```
content-type: application/jsonlines
{"source": "source_sequence_0"}
{"source": "source_sequence_1"}
```
O formato da resposta é o seguinte:
```
accept: application/jsonlines
{"target": "predicted_sequence_0"}
{"target": "predicted_sequence_1"}
```
Para obter detalhes adicionais sobre como serializar e desserializar as entradas e as saídas para formatos específicos de inferência, consulte os [Sequence-to-Sequence Exemplos de cadernos](#seq-2-seq-sample-notebooks).
## Recomendação de instância do EC2 para o algoritmo Sequence-to-Sequence
O algoritmo Amazon SageMaker AI seq2seq só é compatível com tipos de instância de GPU e só pode ser treinado em uma única máquina. No entanto, você pode usar instâncias com várias GPUs. O algoritmo seq2seq oferece apoio para famílias de instâncias de GPU P2, P3, G4dn e G5.
## Sequence-to-Sequence Exemplos de cadernos
Para ver um exemplo de caderno que mostra como usar o algoritmo SageMaker AI Sequence to Sequence para treinar um modelo de tradução inglês-alemão, consulte [Exemplo de tradução automática em inglês-alemão](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html) usando AI Seq2Seq. SageMaker Para obter instruções sobre como criar e acessar instâncias do notebook Jupyter que você pode usar para executar o exemplo em SageMaker IA, consulte. [Instâncias de SageMaker notebook da Amazon](nbi.md) Depois de criar uma instância do notebook e abri-la, selecione a guia **Exemplos de SageMaker IA** para ver uma lista de todas as amostras de SageMaker IA. Os cadernos de exemplo de modelagem de tópicos que usam os algoritmos NTM estão localizados na seção **Introdução a algoritmos da Amazon**. Para abrir um caderno, clique em sua guia **Uso** e selecione **Criar cópia**.
# Como o Sequence-to-Sequence funciona
Normalmente, uma rede neural para sequence-to-sequence modelagem consiste em algumas camadas, incluindo:
+ Uma **camada de incorporação**. Nessa camada, a matriz de entrada, que é codificada por tokens de entrada em uma forma esparsa (por exemplo, codificação one-hot), é mapeada para uma camada de atributos densa. Isso é necessário porque um vetor de características de alta dimensão é mais capaz de codificar informações sobre um determinado token (palavra para corpora de texto) do que um vetor simples. one-hot-encoded Também é uma prática padrão inicializar essa camada de incorporação com um vetor de palavras pré-treinado, como [FastText](https://fasttext.cc/)ou [Glove](https://nlp.stanford.edu/projects/glove/), ou inicializá-la aleatoriamente e aprender os parâmetros durante o treinamento.
+ Uma **camada de codificador**. Depois que os tokens de entrada são mapeados em um espaço de atributo altamente dimensional, a sequência é passada por uma camada de codificador para compactar todas as informações da camada de incorporação de entrada (de toda a sequência) em um vetor de atributo de comprimento fixo. Normalmente, um codificador é feito de redes do tipo RNN, como a memória de longo a curto prazo (LSTM) ou a unidade recorrente fechada (GRU). (O [blog de Christopher Olah](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) explica a LSTM em detalhes.)
+ Uma **camada de decodificador**. A camada de decodificador pega esse vetor de atributo codificado e produz a sequência de tokens de saída. Essa camada também é geralmente criada com arquiteturas (LSTM e GRU).
O modelo inteiro é treinado em conjunto para maximizar a probabilidade da sequência de destino tendo em conta a sequência de origem. Este modelo foi introduzido pela primeira vez por [Sutskever et al.](https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf) em 2014.
**Mecanismo de atenção**. A desvantagem de uma estrutura de codificador e decodificador é que o desempenho do modelo diminui à medida que o comprimento da sequência de origem aumenta, devido ao limite de quantidade de informações que o vetor de atributo codificado de comprimento fixo pode conter. Para enfrentar esse problema, em 2015, Bahdanau et al. propuseram o [mecanismo de atenção](https://arxiv.org/pdf/1409.0473.pdf). Em um mecanismo de atenção, o decodificador tenta encontrar o local na sequência do codificador onde poderiam estar as informações mais importantes e usa essas informações e as palavras decodificadas anteriormente para prever o próximo token na sequência.
Para obter mais detalhes, consulte o whitepaper [Effective Approaches to Attention-based Neural Machine Translation](https://arxiv.org/abs/1508.04025), de Luong, et al., que explica e simplifica cálculos para vários mecanismos de atenção. Além disso, o whitepaper [Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation](https://arxiv.org/abs/1609.08144), de Wu, et al., descreve a arquitetura do Google para tradução automática, que usa conexões de salto entre camadas de codificadores e decodificadores.
# Sequence-to-Sequence Hiperparâmetros
A tabela a seguir lista os hiperparâmetros que você pode definir ao treinar com o algoritmo Amazon SageMaker AI Sequence-to-Sequence (seq2seq).
| Nome do parâmetro | Description |
| --- | --- |
| batch\$1size | Tamanho de minilote para a descida do gradiente. **Opcional** Valores válidos: inteiro positivo Valor padrão: 64 |
| beam\$1size | Comprimento do feixe de pesquisa de feixe. Usado durante o treinamento para calcular `bleu` e usado durante a inferência. **Opcional** Valores válidos: inteiro positivo Valor padrão: 5 |
| bleu\$1sample\$1size | Número de instâncias a escolher do conjunto de dados de validação para decodificar e calcular a pontuação `bleu` durante o treinamento. Defina como -1 para usar o conjunto de validação completo (se `bleu` for escolhido como `optimized_metric`). **Opcional** Valores válidos: inteiro Valor padrão: 0 |
| bucket\$1width | Retorna os buckets (de origem e destino) até o (`max_seq_len_source`, `max_seq_len_target`). O lado mais longo dos dados usa etapas de, `bucket_width` enquanto o lado mais curto usa etapas reduzidas pela proporção média de target/source comprimento. Se um dos lados atingir seu comprimento máximo antes do outro, a largura dos buckets adicionais do lado em questão será fixada em `max_len`. **Opcional** Valores válidos: inteiro positivo Valor padrão: 10 |
| bucketing\$1enabled | Defina como `false` para desabilitar o armazenamento em buckets e desenrolar até o comprimento máximo. **Opcional** Valores válidos: `true` ou `false` Valor padrão: `true` |
| checkpoint\$1frequency\$1num\$1batches | Ponto de verificação e avaliação a cada x lotes. Esse hiperparâmetro de ponto de verificação é passado para o algoritmo seq2seq da SageMaker IA para interromper precocemente e recuperar o melhor modelo. O ponto de verificação do algoritmo é executado localmente no contêiner de treinamento do algoritmo e não é compatível com o ponto de verificação de SageMaker IA. O algoritmo salva temporariamente os pontos de verificação em um caminho local e armazena o melhor artefato do modelo no caminho de saída do modelo no S3 após a interrupção do trabalho de treinamento. **Opcional** Valores válidos: inteiro positivo Valor padrão: 1000 |
| checkpoint\$1threshold | O número máximo de pontos de verificação permitido no modelo para que não haja aumento de `optimized_metric` no conjunto de dados de validação antes de o treinamento ser interrompido. Esse hiperparâmetro de ponto de verificação é passado para o algoritmo seq2seq da SageMaker IA para interromper precocemente e recuperar o melhor modelo. O ponto de verificação do algoritmo é executado localmente no contêiner de treinamento do algoritmo e não é compatível com o ponto de verificação de SageMaker IA. O algoritmo salva temporariamente os pontos de verificação em um caminho local e armazena o melhor artefato do modelo no caminho de saída do modelo no S3 após a interrupção do trabalho de treinamento. **Opcional** Valores válidos: inteiro positivo Valor padrão: 3 |
| clip\$1gradient | Corta os valores de gradiente absoluto maiores que o especificado aqui. Defina como valor negativo para desativar. **Opcional** Valores válidos: flutuante Valor padrão: 1 |
| cnn\$1activation\$1type | O tipo de ativação `cnn` a ser usado. **Opcional** Valores válidos: string. Um destes `glu`, `relu`, `softrelu`, `sigmoid` ou `tanh`. Valor padrão: `glu` |
| cnn\$1hidden\$1dropout | Probabilidade de dropout entre as camadas convolucionais. **Opcional** Valores válidos: flutuante. Intervalo em [0,1]. Valor padrão: 0 |
| cnn\$1kernel\$1width\$1decoder | Largura do kernel para o decodificador `cnn`. **Opcional** Valores válidos: inteiro positivo Valor padrão: 5 |
| cnn\$1kernel\$1width\$1encoder | Largura do kernel para o codificador `cnn`. **Opcional** Valores válidos: inteiro positivo Valor padrão: 3 |
| cnn\$1num\$1hidden | O número de unidades `cnn` ocultas para o codificador e o decodificador. **Opcional** Valores válidos: inteiro positivo Valor padrão: 512 |
| decoder\$1type | Tipo de decodificador. **Opcional** Valores válidos: string. `rnn` ou `cnn`. Valor padrão: *rnn* |
| embed\$1dropout\$1source | Probabilidade de dropout para as incorporações na origem. **Opcional** Valores válidos: flutuante. Intervalo em [0,1]. Valor padrão: 0 |
| embed\$1dropout\$1target | Probabilidade de dropout para as incorporações no destino. **Opcional** Valores válidos: flutuante. Intervalo em [0,1]. Valor padrão: 0 |
| encoder\$1type | Tipo de codificador. A arquitetura `rnn` baseia-se no mecanismo de atenção de Bahdanau e outros cientistas de dados, enquanto a arquitetura *cnn*, no de Gehring e outros cientistas. **Opcional** Valores válidos: string. `rnn` ou `cnn`. Valor padrão: `rnn` |
| fixed\$1rate\$1lr\$1half\$1life | Meia-vida da taxa de aprendizado em termos de número de pontos de verificação para programadores `fixed_rate_`\$1. **Opcional** Valores válidos: inteiro positivo Valor padrão: 10 |
| learning\$1rate | A taxa de aprendizado inicial. **Opcional** Valores válidos: flutuante Valor padrão: 0.0003 |
| loss\$1type | Função de perda para treinamento. **Opcional** Valores válidos: string. `cross-entropy` Valor padrão: `cross-entropy` |
| lr\$1scheduler\$1type | Tipo de agendador de taxa de aprendizado. `plateau_reduce` significa reduzir a taxa de aprendizado sempre que `optimized_metric` em `validation_accuracy` atingir um platô. `inv_t` é a degradação de tempo inversa. `learning_rate`/(1\$1`decay_rate`\$1t) **Opcional** Valores válidos: string. `plateau_reduce`, `fixed_rate_inv_t` ou `fixed_rate_inv_sqrt_t`. Valor padrão: `plateau_reduce` |
| max\$1num\$1batches | Número máximo de updates/batches para processar. -1 para infinito. **Opcional** Valores válidos: inteiro Valor padrão: -1 |
| max\$1num\$1epochs | O número máximo de epochs a passar pelos dados de treinamento antes que o ajuste seja interrompido. O treinamento continua até atingir esse número de epochs, mesmo se a precisão da validação não estiver melhorando com esse parâmetro passado. Ignorado se não for passado. **Opcional** Valores válidos: inteiro positivo e menor que ou igual a max\$1num\$1epochs. Valor padrão: nenhum |
| max\$1seq\$1len\$1source | Comprimento máximo da sequência de origem. Sequências maiores do que o estabelecido são truncadas para atender a esse comprimento. **Opcional** Valores válidos: inteiro positivo Valor padrão: 100 |
| max\$1seq\$1len\$1target | Comprimento máximo da sequência de destino. Sequências maiores do que o estabelecido são truncadas para atender a esse comprimento. **Opcional** Valores válidos: inteiro positivo Valor padrão: 100 |
| min\$1num\$1epochs | Número mínimo de epochs que o treinamento deve executar antes de ser interrompido por condições `early_stopping`. **Opcional** Valores válidos: inteiro positivo Valor padrão: 0 |
| momentum | Constante de dinâmica usada para `sgd`. Não passe esse parâmetro se estiver usando `adam` ou `rmsprop`. **Opcional** Valores válidos: flutuante Valor padrão: nenhum |
| num\$1embed\$1source | Tamanho da incorporação para tokens de origem. **Opcional** Valores válidos: inteiro positivo Valor padrão: 512 |
| num\$1embed\$1target | Tamanho da incorporação para tokens de destino. **Opcional** Valores válidos: inteiro positivo Valor padrão: 512 |
| num\$1layers\$1decoder | Número de camadas do decodificador *rnn* ou *cnn*. **Opcional** Valores válidos: inteiro positivo Valor padrão: 1 |
| num\$1layers\$1encoder | Número de camadas para o codificador `rnn` ou `cnn`. **Opcional** Valores válidos: inteiro positivo Valor padrão: 1 |
| optimized\$1metric | Métricas a otimizar com a interrupção precoce. **Opcional** Valores válidos: string. `perplexity`, `accuracy` ou `bleu`. Valor padrão: `perplexity` |
| optimizer\$1type | Otimizador a ser escolhido. **Opcional** Valores válidos: string. `adam`, `sgd` ou `rmsprop`. Valor padrão: `adam` |
| plateau\$1reduce\$1lr\$1factor | Fator de multiplicação da taxa de aprendizado (para `plateau_reduce`). **Opcional** Valores válidos: flutuante Valor padrão: 0.5 |
| plateau\$1reduce\$1lr\$1threshold | Para o programador `plateau_reduce`, multiplique a taxa de aprendizado com fator de redução se `optimized_metric` não melhorar para essa quantidade de pontos de verificação. **Opcional** Valores válidos: inteiro positivo Valor padrão: 3 |
| rnn\$1attention\$1in\$1upper\$1layers | Passa a atenção para as camadas superiores da *rnn*, como no whitepaper sobre NMT do Google. Aplicável somente no uso de mais de uma camada. **Opcional** Valores válidos: booliano (`true` ou `false`) Valor padrão: `true` |
| rnn\$1attention\$1num\$1hidden | Número de unidades ocultas para camadas de atenção. O padrão é `rnn_num_hidden`. **Opcional** Valores válidos: inteiro positivo Valor padrão: `rnn_num_hidden` |
| rnn\$1attention\$1type | Modelo de atenção para codificadores. `mlp` refere-se a concat e bilinear refere-se ao geral de Luong et al. paper. **Opcional** Valores válidos: string. Um destes: `dot`, `fixed`, `mlp` ou `bilinear`. Valor padrão: `mlp` |
| rnn\$1cell\$1type | Tipo específico de arquitetura `rnn`. **Opcional** Valores válidos: string. `lstm` ou `gru`. Valor padrão: `lstm` |
| rnn\$1decoder\$1state\$1init | Como os estados do decodificador `rnn` devem ser inicializados nos codificadores. **Opcional** Valores válidos: string. `last`, `avg` ou `zero`. Valor padrão: `last` |
| rnn\$1first\$1residual\$1layer | A primeira camada *rnn* a ter uma conexão residual; aplicável apenas se o número de camadas no codificador ou decodificador for maior que 1. **Opcional** Valores válidos: inteiro positivo Valor padrão: 2 |
| rnn\$1num\$1hidden | O número de unidades *rnn* ocultas para o codificador e o decodificador. O valor deve ser um múltiplo de 2 porque o algoritmo usa LSTM (Bi-directional Long Term Short Term Memory) por padrão. **Opcional** Valores válidos: inteiro positivo par Valor padrão: 1024 |
| rnn\$1residual\$1connections | Conexão residual a ser adicionada à *rnn* empilhada. O número de camadas deve ser maior que 1. **Opcional** Valores válidos: booliano (`true` ou `false`) Valor padrão: `false` |
| rnn\$1decoder\$1hidden\$1dropout | Probabilidade de abandono para estado oculto que combina o contexto com o estado oculto da *rnn* no decodificador. **Opcional** Valores válidos: flutuante. Intervalo em [0,1]. Valor padrão: 0 |
| training\$1metric | Métricas a acompanhar no treinamento de dados de validação. **Opcional** Valores válidos: string. `perplexity` ou `accuracy`. Valor padrão: `perplexity` |
| weight\$1decay | Constante da degradação de peso. **Opcional** Valores válidos: flutuante Valor padrão: 0 |
| weight\$1init\$1scale | Escala da inicialização de peso (para as inicializações `uniform` e `xavier`). **Opcional** Valores válidos: flutuante Valor padrão: 2.34 |
| weight\$1init\$1type | Tipo de inicialização de peso. **Opcional** Valores válidos: string. `uniform` ou `xavier`. Valor padrão: `xavier` |
| xavier\$1factor\$1type | Tipo de fator Xavier. **Opcional** Valores válidos: string. `in`, `out` ou `avg`. Valor padrão: `in` |
# Ajustar um Sequence-to-Sequence modelo
O *ajuste automático de modelos*, também conhecido como ajuste de hiperparâmetros, localiza a melhor versão de um modelo executando vários trabalhos que testam uma série de hiperparâmetros no seu conjunto de dados. Você escolhe os hiperparâmetros ajustáveis, um intervalo de valores para cada um e uma métrica objetiva. Você escolhe a métrica objetiva entre as métricas que o algoritmo calcula. O ajuste de modelo automático pesquisa os hiperparâmetros escolhidos para encontrar a combinação de valores que resultam no modelo que otimiza a métrica objetiva.
Para mais informações sobre o ajuste de modelos, consulte [Ajuste automático do modelo com SageMaker IA](automatic-model-tuning.md).
## Métricas calculadas pelo algoritmo Sequence-to-Sequence
O algoritmo sequence to sequence relata três métricas que são calculadas durante o treinamento. Escolha um deles como um objetivo para otimizar ao ajustar os valores dos hiperparâmetros.
| Nome da métrica | Description | Direção de otimização |
| --- | --- | --- |
| validation:accuracy | Precisão calculada no conjunto de dados de validação. | Maximizar |
| validation:bleu | Pontuação [Bleu](https://en.wikipedia.org/wiki/BLEU) calculada no conjunto de dados de validação. Como o cálculo de BLEU é caro, você pode optar por calcular o BLEU em uma subamostra aleatória do conjunto de dados de validação para acelerar o processo geral de treinamento. Use o parâmetro `bleu_sample_size` para especificar a subamostra. | Maximizar |
| validation:perplexity | [Perplexidade](https://en.wikipedia.org/wiki/Perplexity), é uma função de perda calculada no conjunto de dados de validação. A perplexidade mede a entropia cruzada entre uma amostra empírica e a distribuição prevista por um modelo e, assim, fornece uma medida de quão bem um modelo prediz os valores da amostra. Modelos que são bons em predizer uma amostra têm baixa perplexidade. | Minimizar |
## Hiperparâmetros ajustáveis Sequence-to-Sequence
Você pode ajustar os seguintes hiperparâmetros para o algoritmo SageMaker AI Sequence to Sequence. Os hiperparâmetros que têm o maior impacto nas métricas objetivas de sequence to sequence são: `batch_size`, `optimizer_type`, `learning_rate`, `num_layers_encoder` e `num_layers_decoder`.
| Nome do parâmetro | Tipo de parâmetro | Intervalos recomendados |
| --- | --- | --- |
| 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 | Para o tipo xavier: MinValue: 2.0, MaxValue: 3.0 Para o tipo 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 | Aplicável somente a redes neurais recorrentes (RNNs). [128,256,512,1024,2048] |
| cnn\$1num\$1hidden | CategoricalParameterRange | Aplicável somente a redes neurais convolucionais (). 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] |