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á.
# Algoritmos de SageMaker IA integrados para dados de texto
SageMaker A IA fornece algoritmos personalizados para a análise de documentos textuais usados no processamento de linguagem natural, classificação ou resumo de documentos, modelagem ou classificação de tópicos e transcrição ou tradução de idiomas.
+ [BlazingText algoritmo](blazingtext.md): uma implantação altamente otimizada do Word2vec e dos algoritmos de classificação de texto que podem ser facilmente escalados para grandes conjuntos de dados. É útil para muitas tarefas posteriores de processamento de linguagem natural (PLN).
+ [Algoritmo Latent Dirichlet Allocation (LDA)](lda.md)Esse algoritmo é adequado para determinar tópicos em um conjunto de documentos. É um algoritmo *não supervisionado*, o que significa que ele não usa dados de exemplo com respostas durante o treinamento.
+ [Algoritmo de Modelo de tópicos neurais (NTM)](ntm.md): outra técnica não supervisionada para determinar tópicos em um conjunto de documentos, usando uma abordagem de rede neural.
+ [Algoritmo Object2Vec](object2vec.md): um algoritmo de incorporação neural de uso geral que pode ser usado para sistemas de recomendação, classificação de documentos e incorporação de frases.
+ [Sequence-to-Sequence Algoritimo](seq-2-seq.md): esse algoritmo supervisionado é comumente usado para tradução de máquina neural.
+ [Classificação de texto - TensorFlow](text-classification-tensorflow.md): um algoritmo supervisionado que oferece suporte ao aprendizado por transferência com modelos pré-treinados disponíveis para classificação de texto.
| Nome do algoritmo | Nome do canal | Modo de entrada do treinamento | Tipo de arquivo | Classe de instância | Paralelizável |
| --- | --- | --- | --- | --- | --- |
| BlazingText | treinamento | Arquivo ou Pipe | Arquivo de texto (uma frase por linha com tokens separados por espaço) | GPU (somente instância única) ou CPU | Não |
| LDA | treinamento e (opcionalmente) teste | Arquivo ou Pipe | recordIO-protobuf ou CSV | CPU (somente instância única) | Não |
| Modelo de tópico neural | treinamento e (opcionalmente) validação, teste ou ambos | Arquivo ou Pipe | recordIO-protobuf ou CSV | GPU ou CPU | Sim |
| Object2Vec | treinamento e (opcionalmente) validação, teste ou ambos | Arquivo | Linhas JSON | GPU ou CPU (somente instância única) | Não |
| Modelagem Seq2Seq | treinamento, validação e vocabulário | Arquivo | recordIO-protobuf | GPU (somente instância única) | Não |
| Classificação de texto - TensorFlow | treinamento e validação | Arquivo | CSV | CPU ou GPU | Sim (somente em vários GPUs em uma única instância) |
# BlazingText algoritmo
O BlazingText algoritmo Amazon SageMaker AI fornece implementações altamente otimizadas do Word2vec e dos algoritmos de classificação de texto. O algoritmo Word2vec é útil para várias tarefas posteriores de processamento de linguagem natural (NLP), como análise de sentimento, reconhecimento de entidades nomeadas, tradução automática, etc. A classificação de texto é uma tarefa importante para aplicativos que realizam pesquisas na web, recuperação de informações, classificação e classificação de documentos.
O algoritmo Word2vec mapeia palavras para vetores distribuídos de alta qualidade. A representação vetorial resultante de uma palavra é chamada de *incorporação da palavra*. Palavras semanticamente semelhantes correspondem a vetores próximos uns dos outros. Dessa forma, incorporações de palavras capturam as relações semânticas entre as palavras.
Muitos aplicativos de processamento de linguagem natural (NLP) aprendem incorporações de palavras por meio de treinamentos em grandes coleções de documentos. Essas representações vetoriais pré-treinadas fornecem informações sobre semântica e distribuições de palavras que normalmente melhoram a generalização de outros modelos que são posteriormente treinados em uma quantidade mais limitada de dados. A maioria das implementações do algoritmo Word2vec é otimizada para arquiteturas de CPU de vários núcleos. Isso torna difícil dimensionar para grandes conjuntos de dados.
Com o BlazingText algoritmo, você pode escalar facilmente para grandes conjuntos de dados. Semelhante ao Word2vec, ele fornece as arquiteturas de treinamento Skip-gram e contínuo bag-of-words (CBOW). BlazingText[A implementação do algoritmo supervisionado de classificação de texto multiclasse e vários rótulos estende o classificador de texto FastText para usar a aceleração de GPU com kernels CUDA personalizados.](https://docs.nvidia.com/cuda/index.html) Você pode treinar um modelo em mais de um bilhão de palavras em alguns minutos usando uma CPU de vários núcleos ou uma GPU. Além disso, você obtém um desempenho equivalente ao dos algoritmos de classificação de texto de aprendizado state-of-the-art profundo.
O BlazingText algoritmo não é paralelizável. Para obter mais informações sobre parâmetros relacionados ao treinamento, consulte [Caminhos de registro do Docker para algoritmos SageMaker integrados](https://docs.aws.amazon.com/en_us/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html).
Os BlazingText algoritmos de SageMaker IA fornecem os seguintes recursos:
+ Treinamento acelerado do classificador de texto FastText em CPUs vários núcleos ou GPU e do GPUs Word2Vec no uso de kernels CUDA altamente otimizados. Para obter mais informações, consulte [BlazingText: Dimensionando e acelerando o Word2Vec](https://dl.acm.org/citation.cfm?doid=3146347.3146354) usando vários. GPUs
+ [Vetores de palavras enriquecidos com informações de subpalavras](https://arxiv.org/abs/1607.04606), aprendendo representações vetoriais para n-gramas de caracteres. Essa abordagem permite BlazingText gerar vetores significativos para palavras out-of-vocabulary (OOV), representando seus vetores como a soma dos vetores de caracteres n-gramas (subpalavra).
+ Um `batch_skipgram` `mode` para o algoritmo Word2Vec que permite treinamentos mais rápidos e computação distribuída entre vários nós de CPU. Esse `batch_skipgram` `mode` faz minilotes usando a estratégia de compartilhamento de amostras negativas para converter operações BLAS de nível 1 em operações BLAS de nível 3. Isso aproveita eficientemente as instruções de multiplicação-adição de arquiteturas modernas. Para obter mais informações, consulte este artigo sobre [paralelização do Word2Vec em memória compartilhada e distribuída](https://arxiv.org/pdf/1604.04661.pdf).
Para resumir, os seguintes modos são compatíveis com instâncias de tipos diferentes: BlazingText
| Modos | Word2Vec (Aprendizagem não supervisionada) | Classificação de texto (Aprendizagem supervisionada) |
| --- | --- | --- |
| Instância de CPU única | `cbow` `Skip-gram` `Batch Skip-gram` | `supervised` |
| Instância única de GPU (com 1 ou mais GPUs) | `cbow` `Skip-gram` | `supervised` com uma GPU |
| Várias instâncias de CPU | Batch Skip-gram | Nenhum |
Para obter mais informações sobre a matemática por trás BlazingText, consulte [BlazingText: Dimensionando e acelerando o Word2Vec](https://dl.acm.org/citation.cfm?doid=3146347.3146354) usando vários. GPUs
**Topics**
+ [Interface de entrada/saída para o algoritmo BlazingText](#bt-inputoutput)
+ [Recomendação de instância do EC2 para o algoritmo BlazingText](#blazingtext-instances)
+ [BlazingText Amostras de cadernos](#blazingtext-sample-notebooks)
+ [BlazingText Hiperparâmetros](blazingtext_hyperparameters.md)
+ [Ajustar um BlazingText modelo](blazingtext-tuning.md)
## Interface de entrada/saída para o algoritmo BlazingText
O BlazingText algoritmo espera um único arquivo de texto pré-processado com tokens separados por espaço. Cada linha no arquivo deve conter uma única frase. Se você precisar treinar em vários arquivos de texto, concatene-os em um único arquivo e faça upload desse arquivo no respectivo canal.
### Formato de dados de treinamento e validação
#### Formato de dados de treinamento e validação para o algoritmo Word2Vec
Para o treinamento de Word2Vec, faça upload do arquivo no canal *train*. Nenhum outro canal é aceito. O arquivo deve conter uma frase de treinamento por linha.
#### Formato de dados de treinamento e validação para o algoritmo de classificação de texto
Para o modo supervisionado, você pode treinar com o modo de arquivo ou com o formato de texto manifesto aumentado.
##### Treinar com o modo de arquivo
Para o `supervised` modo, o training/validation arquivo deve conter uma frase de treinamento por linha junto com os rótulos. Rótulos são palavras prefixadas pela string *\$1\$1label\$1\$1*. Aqui está um exemplo de um training/validation arquivo:
```
__label__4 linux ready for prime time , intel says , despite all the linux hype , the open-source movement has yet to make a huge splash in the desktop market . that may be about to change , thanks to chipmaking giant intel corp .
__label__2 bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly as the indian skippers return to international cricket was short lived .
```
**nota**
A ordem dos rótulos dentro da frase não importa.
Faça upload do arquivo de treinamento no canal de "treinamento" e, opcionalmente, faça upload do arquivo de validação no canal de "validação".
##### Treinar com o formato de texto manifesto aumentado
O modo supervisionado para instâncias de CPU também oferece suporte para o formato de manifesto aumentado, que permite fazer treinamentos no modo pipe sem a necessidade de criar arquivos RecordIO. Ao usar o formato, é necessário gerar um arquivo manifesto do S3 contendo a lista de frases e seus rótulos correspondentes. O formato de arquivo de manifesto deve estar no formato [linhas JSON](http://jsonlines.org/), em que cada linha representa uma amostra. As frases são especificadas usando a tag `source`, e o rótulo pode ser especificado usando a tag `label`. Ambas as tags `source` e `label` devem ser provisionadas com o valor do parâmetro `AttributeNames` conforme especificado na solicitação.
```
{"source":"linux ready for prime time , intel says , despite all the linux hype", "label":1}
{"source":"bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly", "label":2}
```
O treinamento com vários rótulos também é compatível com a especificação de uma matriz de rótulos JSON.
```
{"source":"linux ready for prime time , intel says , despite all the linux hype", "label": [1, 3]}
{"source":"bowled by the slower one again , kolkata , november 14 the past caught up with sourav ganguly", "label": [2, 4, 5]}
```
Para obter mais informações sobre arquivos manifestos aumentados, consulte [Arquivos de Manifestos Aumentados em Trabalhos de Treinamento](augmented-manifest.md).
### Artefatos de modelo e inferência
#### Artefatos de modelo para o algoritmo Word2Vec
Para o treinamento do Word2Vec, os artefatos do modelo consistem em *vectors.txt*, que contém words-to-vectors mapeamento, e *vectors.bin*, um binário usado BlazingText para hospedagem, inferência ou ambos. O *vectors.txt* armazena os vetores em um formato compatível com outras ferramentas, como Gensim e Spacy. Por exemplo, um usuário do Gensim pode executar os seguintes comandos para carregar o arquivo vectors.txt:
```
from gensim.models import KeyedVectors
word_vectors = KeyedVectors.load_word2vec_format('vectors.txt', binary=False)
word_vectors.most_similar(positive=['woman', 'king'], negative=['man'])
word_vectors.doesnt_match("breakfast cereal dinner lunch".split())
```
Se o parâmetro de avaliação estiver definido como `True`, um arquivo adicional, *eval.json*, será criado. Esse arquivo contém os resultados da avaliação de similaridade (utilizando coeficientes de correlação de Spearman) no conjunto de dados WS-353. É relatado o número de palavras do conjunto de dados WS-353 que não estão no corpo de treinamento.
Para solicitações de inferência, o modelo aceita um arquivo JSON contendo uma lista de strings e retorna uma lista de vetores. Se a palavra não for encontrada no vocabulário, a inferência retornará um vetor de zeros. Se as subpalavras forem definidas como `True` durante o treinamento, o modelo poderá gerar vetores para palavras out-of-vocabulary (OOV).
##### Solicitação JSON de amostra
Mime-type:` application/json`
```
{
"instances": ["word1", "word2", "word3"]
}
```
#### Artefatos de modelo para o algoritmo de classificação de texto
O treinamento com saídas supervisionadas cria um arquivo *model.bin* que pode ser consumido pela BlazingText hospedagem. Para inferência, o BlazingText modelo aceita um arquivo JSON contendo uma lista de sentenças e retorna uma lista dos rótulos previstos e pontuações de probabilidade correspondentes. Cada frase deve ser uma string com tokens separados por espaço, palavras ou ambos.
##### Solicitação JSON de amostra
Mime-type:` application/json`
```
{
"instances": ["the movie was excellent", "i did not like the plot ."]
}
```
Por padrão, o servidor retorna apenas uma previsão, aquela com a maior probabilidade. Para recuperar as *k* principais previsões, você pode definir *k* na configuração, da seguinte maneira:
```
{
"instances": ["the movie was excellent", "i did not like the plot ."],
"configuration": {"k": 2}
}
```
Pois BlazingText, os `accept` parâmetros ` content-type` e devem ser iguais. Para a transformação em lote, ambos precisam ser `application/jsonlines`. Se eles forem diferentes, o campo `Accept` será ignorado. O formato para a entrada é:
```
content-type: application/jsonlines
{"source": "source_0"}
{"source": "source_1"}
if you need to pass the value of k for top-k, then you can do it in the following way:
{"source": "source_0", "k": 2}
{"source": "source_1", "k": 3}
```
O formato para a saída é:
```
accept: application/jsonlines
{"prob": [prob_1], "label": ["__label__1"]}
{"prob": [prob_1], "label": ["__label__1"]}
If you have passed the value of k to be more than 1, then response will be in this format:
{"prob": [prob_1, prob_2], "label": ["__label__1", "__label__2"]}
{"prob": [prob_1, prob_2], "label": ["__label__1", "__label__2"]}
```
Para os modos supervisionado (classificação de texto) e não supervisionado (Word2Vec), os binários (*\$1.bin)* produzidos por podem ser BlazingText consumidos de forma cruzada pelo FastText e vice-versa. Você pode usar binários produzidos BlazingText pelo FastText. Da mesma forma, você pode hospedar os binários do modelo criados com o BlazingText FastText usando.
Aqui está um exemplo de como usar um modelo gerado BlazingText com o FastText:
```
#Download the model artifact from S3
aws s3 cp s3:////model.tar.gz model.tar.gz
#Unzip the model archive
tar -xzf model.tar.gz
#Use the model archive with fastText
fasttext predict ./model.bin test.txt
```
No entanto, os binários só são compatíveis quando o treinamento em CPU e GPU única; o treinamento em várias GPUs não produzirá binários.
## Recomendação de instância do EC2 para o algoritmo BlazingText
Para `skipgram` modos `cbow` e, BlazingText oferece suporte a instâncias de CPU única e GPU única. Ambos os modos oferecem suporte para a aprendizagem de incorporações `subwords`. Para alcançar a velocidade mais alta sem comprometer a precisão, recomendamos que você use uma instância ml.p3.2xlarge.
Para o `batch_skipgram` modo, BlazingText oferece suporte a uma ou várias instâncias de CPU. Ao treinar em várias instâncias, defina o valor do `S3DataDistributionType` campo do [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html)objeto [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)para o qual você passa`FullyReplicated`. BlazingTextcuida da distribuição de dados entre máquinas.
Para o modo de classificação de texto supervisionado, uma instância C5 é recomendada se o conjunto de dados de treinamento é menor que 2 GB. Para conjuntos de dados maiores, use uma instância com uma única GPU. BlazingText suporta instâncias P2, P3, G4dn e G5 para treinamento e inferência.
## BlazingText Amostras de cadernos
Para ver um exemplo de caderno que treina e implanta o BlazingText algoritmo de SageMaker IA para gerar vetores de palavras, consulte [Aprendendo representações de palavras Word2Vec](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/blazingtext_word2vec_text8/blazingtext_word2vec_text8.html) usando. BlazingText 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 e abrir uma instância do notebook, escolha a guia **Exemplos de SageMaker IA** para ver uma lista de todos os exemplos de SageMaker IA. Os blocos de anotações de exemplo de modelagem de tópicos que usam o Blazing Text estão localizados na seção **Introdução a algoritmos da Amazon**. Para abrir um caderno, escolha a guia **Uso** e depois escolha **Criar cópia**.
# BlazingText Hiperparâmetros
Ao iniciar um trabalho de treinamento com uma solicitação `CreateTrainingJob`, você especifica um algoritmo de treinamento. Você também pode especificar hiperparâmetros específicos do algoritmo como mapas. string-to-string Os hiperparâmetros do BlazingText algoritmo dependem do modo usado: Word2Vec (não supervisionado) e Classificação de texto (supervisionado).
## Hiperparâmetros do Word2Vec
A tabela a seguir lista os hiperparâmetros do algoritmo de treinamento BlazingText Word2Vec fornecido pela Amazon AI. SageMaker
| Nome do parâmetro | Description |
| --- | --- |
| mode | A arquitetura do Word2vec usada para treinamento. **Obrigatório** Valores válidos: `batch_skipgram`, `skipgram` ou `cbow` |
| batch\$1size | O tamanho de cada lote quando `mode` está definido como `batch_skipgram`. Defina um número de 10 a 20. **Opcional** Valores válidos: inteiro positivo Valor padrão: 11 |
| buckets | O número de buckets de hash a serem usados para subpalavras. **Opcional** Valores válidos: inteiro positivo Valor padrão: 2000000 |
| epochs | O número de passagens completas pelos dados de treinamento. **Opcional** Valores válidos: inteiro positivo Valor padrão: 5 |
| evaluation | Se o modelo treinado é avaliado usando o teste [WordSimilarity-353](http://www.gabrilovich.com/resources/data/wordsim353/wordsim353.html). **Opcional** Valores válidos: (booleano) `True` ou `False` Valor padrão: `True` |
| learning\$1rate | O tamanho da etapa usado para atualizações de parâmetros. **Opcional** Valores válidos: flutuante positivo Valor padrão: 0.05 |
| min\$1char | O número mínimo de caracteres a ser usado para subpalavras/n-gramas de caracteres. **Opcional** Valores válidos: inteiro positivo Valor padrão: 3 |
| min\$1count | Palavras que aparecem menos de `min_count` vezes são descartadas. **Opcional** Valores válidos: inteiro não negativo Valor padrão: 5 |
| max\$1char | O número máximo de caracteres a serem usados para subpalavras/n-gramas de caracteres **Opcional** Valores válidos: inteiro positivo Valor padrão: 6 |
| negative\$1samples | O número de amostras negativas para a estratégia de compartilhamento de amostras negativas. **Opcional** Valores válidos: inteiro positivo Valor padrão: 5 |
| sampling\$1threshold | O limite para a ocorrência de palavras. Palavras que aparecem com maior frequência nos dados de treinamento são amostradas aleatoriamente. **Opcional** Valores válidos: fração positiva. O intervalo recomendado é (0, 1e-3] Valor padrão: 0.0001 |
| subwords | Se incorporações de subpalavras devem ou não ser aprendidas. **Opcional** Valores válidos: (booleano) `True` ou `False` Valor padrão: `False` |
| vector\$1dim | A dimensão dos vetores de palavra que o algoritmo aprende. **Opcional** Valores válidos: inteiro positivo Valor padrão: 100 |
| window\$1size | O tamanho da janela de contexto. Janela de contexto é o número de palavras em torno da palavra de destino usada para treinamento. **Opcional** Valores válidos: inteiro positivo Valor padrão: 5 |
## Hiperparâmetros de classificação de texto
A tabela a seguir lista os hiperparâmetros do algoritmo de treinamento de classificação de texto fornecido pela Amazon SageMaker AI.
**nota**
Embora alguns dos parâmetros sejam comuns entre os modos de Classificação de texto e Word2Vec, eles podem ter significados diferentes dependendo do contexto.
| Nome do parâmetro | Description |
| --- | --- |
| mode | O modo de treinamento. **Obrigatório** Valores válidos: `supervised` |
| buckets | O número de buckets de hash a serem usados para n-gramas de palavras. **Opcional** Valores válidos: inteiro positivo Valor padrão: 2000000 |
| early\$1stopping | Se o treinamento deve ou não ser interrompido caso a precisão de validação não melhore depois de um `patience` número de epochs. Observe que um canal de validação é obrigatório se a parada antecipada for usada. **Opcional** Valores válidos: (booleano) `True` ou `False` Valor padrão: `False` |
| epochs | O número máximo de passagens completas pelos dados de treinamento. **Opcional** Valores válidos: inteiro positivo Valor padrão: 5 |
| learning\$1rate | O tamanho da etapa usado para atualizações de parâmetros. **Opcional** Valores válidos: flutuante positivo Valor padrão: 0.05 |
| min\$1count | Palavras que aparecem menos de `min_count` vezes são descartadas. **Opcional** Valores válidos: inteiro não negativo Valor padrão: 5 |
| min\$1epochs | O número mínimo de epochs a treinar antes que a lógica de interrupção precoce seja invocada. **Opcional** Valores válidos: inteiro positivo Valor padrão: 5 |
| patience | O número de epochs a aguardar antes de aplicar a interrupção precoce quando nenhum progresso é feito no conjunto de validação. Usado somente quando `early_stopping` é `True`. **Opcional** Valores válidos: inteiro positivo Valor padrão: 4 |
| vector\$1dim | A dimensão da camada de incorporação. **Opcional** Valores válidos: inteiro positivo Valor padrão: 100 |
| word\$1ngrams | O número de recursos de n-gramas de palavras a serem usados. **Opcional** Valores válidos: inteiro positivo Valor padrão: 2 |
# Ajustar um BlazingText 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 BlazingText
O algoritmo BlazingText Word2Vec (`skipgram`,`cbow`, e `batch_skipgram` modos) relata uma única métrica durante o treinamento:. `train:mean_rho` Esta métrica é calculada em [conjuntos de dados de semelhança de palavras WS-353](https://aclweb.org/aclwiki/WordSimilarity-353_Test_Collection_(State_of_the_art)). Ao ajustar os valores de hiperparâmetros para o algoritmo Word2Vec, use essa métrica como o objetivo.
O algoritmo de Classificação de BlazingText Texto (`supervised`modo) também relata uma única métrica durante o treinamento: `validation:accuracy` a. Ao ajustar os valores de hiperparâmetros para o algoritmo de classificação de texto, use estas métricas como o objetivo.
| Nome da métrica | Description | Direção de otimização |
| --- | --- | --- |
| train:mean\$1rho | O rho (coeficiente de correlação de classificação de Spearman) médio em [conjuntos de dados de semelhança de palavras WS-353](http://alfonseca.org/pubs/ws353simrel.tar.gz) | Maximizar |
| validation:accuracy | A precisão da classificação no conjunto de dados de validação especificado pelo usuário | Maximizar |
## Hiperparâmetros ajustáveis BlazingText
### Hyperparameters ajustáveis para o algoritmo Word2Vec
Ajuste um modelo Amazon SageMaker AI BlazingText Word2Vec com os seguintes hiperparâmetros. Os hiperparâmetros que têm o maior impacto nas métricas objetivas de Word2Vec são: `mode`, ` learning_rate`, `window_size`, `vector_dim` e `negative_samples`.
| Nome do parâmetro | Tipo de parâmetro | Intervalos ou valores recomendados |
| --- | --- | --- |
| batch\$1size | `IntegerParameterRange` | [8-32] |
| epochs | `IntegerParameterRange` | [5-15] |
| learning\$1rate | `ContinuousParameterRange` | MinValue: 0,005, MaxValue: 0,01 |
| min\$1count | `IntegerParameterRange` | [0-100] |
| mode | `CategoricalParameterRange` | [`'batch_skipgram'`, `'skipgram'`, `'cbow'`] |
| negative\$1samples | `IntegerParameterRange` | [5-25] |
| sampling\$1threshold | `ContinuousParameterRange` | MinValue: 0,0001, MaxValue: 0,001 |
| vector\$1dim | `IntegerParameterRange` | [32-300] |
| window\$1size | `IntegerParameterRange` | [1-10] |
### Hiperparâmetros ajustáveis para o algoritmo de classificação de texto
Ajuste um modelo de classificação BlazingText de texto da Amazon SageMaker AI com os seguintes hiperparâmetros.
| Nome do parâmetro | Tipo de parâmetro | Intervalos ou valores recomendados |
| --- | --- | --- |
| buckets | `IntegerParameterRange` | [1000000-10000000] |
| epochs | `IntegerParameterRange` | [5-15] |
| learning\$1rate | `ContinuousParameterRange` | MinValue: 0,005, MaxValue: 0,01 |
| min\$1count | `IntegerParameterRange` | [0-100] |
| vector\$1dim | `IntegerParameterRange` | [32-300] |
| word\$1ngrams | `IntegerParameterRange` | [1-3] |
# Algoritmo Latent Dirichlet Allocation (LDA)
O algoritmo de alocação latente de Dirichlet (LDA) do Amazon SageMaker AI é um algoritmo de aprendizado não supervisionado que tenta descrever um conjunto de observações como uma combinação de categorias distintas. É mais comumente usado para descobrir um número de tópicos especificado pelo usuário, compartilhado por documentos dentro de um corpus de textos. Aqui, cada observação é um documento, os recursos são a presença (ou contagem de ocorrências) de cada palavra, e as categorias são os tópicos. Como é um método não supervisionado, os tópicos não são especificados de antemão e não há garantias de que sua categorização de documentos seja similar a como um humano normalmente faria. Os tópicos são aprendidos como uma distribuição de probabilidade sobre as palavras que ocorrem em cada documento. Cada documento, por sua vez, é descrito como uma combinação de tópicos.
O conteúdo exato de dois documentos com combinações de tópicos semelhantes não será o mesmo. Mas, em geral, espera-se que esses documentos usem com mais frequência um subconjunto compartilhado de palavras, em vez de compará-las com um documento de uma combinação diferente de tópicos. Isso permite que o LDA descubra esses grupos de palavras e os utilize para formar tópicos. Como um exemplo extremamente simples, tendo em conta um conjunto de documentos em que as únicas palavras que ocorrem são: *comer*, *dormir*, *brincar*, *miar* e *latir*, o LDA pode produzir tópicos como estes:
| **Tópico** | *comer* | *dormir* | *brincar* | *miar* | *latir* |
| --- | --- | --- | --- | --- | --- |
| Tópico 1 | 0,1 | 0.3 | 0.2 | 0.4 | 0.0 |
| Tópico 2 | 0.2 | 0,1 | 0.4 | 0.0 | 0.3 |
É possível inferir que os documentos com mais probabilidade de se encaixar no Tópico 1 são sobre gatos (que tendem a *miar* e *dormir* mais), e que os documentos que se encaixam no Tópico 2 são sobre cães (que preferem *brincar* e *latir*). Esses tópicos podem ser encontrados mesmo que as palavras cão e gato nunca aparecem em nenhum dos textos.
**Topics**
+ [Escolha entre Latent Dirichlet Allocation (LDA) e modelo de tópico neural (NTM)](#lda-or-ntm)
+ [Interface de entrada/saída para o algoritmo LDA](#lda-inputoutput)
+ [Recomendação de instâncias do EC2 para o algoritmo LDA](#lda-instances)
+ [Cadernos de exemplo do LDA](#LDA-sample-notebooks)
+ [Como o LDA funciona](lda-how-it-works.md)
+ [Hiperparâmetros do LDA](lda_hyperparameters.md)
+ [Ajustar um modelo LDA](lda-tuning.md)
## Escolha entre Latent Dirichlet Allocation (LDA) e modelo de tópico neural (NTM)
Modelos de tópicos são comumente usados para produzir tópicos a partir de corpus que (1) encapsulam coerentemente o significado semântico e (2) descrevem bem os documentos. Dessa forma, os modelos de tópicos visam minimizar a perplexidade e maximizar a coerência do tópico.
Perplexidade é uma métrica intrínseca de avaliação de modelagem de linguagem que mede o inverso da probabilidade da média geométrica por palavra em seus dados de teste. Uma pontuação de perplexidade mais baixa indica melhor desempenho de generalização. A pesquisa mostrou que a probabilidade calculada por palavra muitas vezes não se alinha ao julgamento humano e pode ser totalmente não correlacionada, portanto, foi introduzida a coerência do tópico. Cada tópico inferido do seu modelo consiste em palavras, e a coerência do tópico é calculada com base nas N palavras principais para esse tópico específico do seu modelo. Muitas vezes é definido como a média ou mediana das pontuações de similaridade de palavras entre pares das palavras naquele tópico, por exemplo, Pointwise Mutual Information (PMI). Um modelo promissor gera tópicos coerentes ou tópicos com altas pontuações de coerência de tópicos.
Embora o objetivo seja treinar um modelo de tópico que minimize a perplexidade e maximize a coerência do tópico, muitas vezes há uma compensação entre LDA e NTM. Uma pesquisa recente da Amazon, Dinget et al., 2018 mostrou que o NTM é promissor para alcançar alta coerência de tópicos, mas o LDA treinado com amostragem de Gibbs reduzida atinge melhor perplexidade. Há uma compensação entre perplexidade e coerência tópica. Do ponto de vista prático em relação ao hardware e à potência computacional, o hardware do SageMaker NTM é mais flexível do que o LDA e pode ser escalado melhor porque o NTM pode ser executado em CPU e GPU e pode ser paralelizado em várias instâncias de GPU, enquanto o LDA só oferece suporte ao treinamento de CPU em uma única instância.
**Topics**
+ [Escolha entre Latent Dirichlet Allocation (LDA) e modelo de tópico neural (NTM)](#lda-or-ntm)
+ [Interface de entrada/saída para o algoritmo LDA](#lda-inputoutput)
+ [Recomendação de instâncias do EC2 para o algoritmo LDA](#lda-instances)
+ [Cadernos de exemplo do LDA](#LDA-sample-notebooks)
+ [Como o LDA funciona](lda-how-it-works.md)
+ [Hiperparâmetros do LDA](lda_hyperparameters.md)
+ [Ajustar um modelo LDA](lda-tuning.md)
## Interface de entrada/saída para o algoritmo LDA
No LDA, espera-se que os dados sejam fornecidos no canal de treinamento. Opcionalmente, o algoritmo é compatível com um canal de teste, que é pontuado pelo modelo final. O LDA é compatível com os formatos de arquivo `recordIO-wrapped-protobuf` (denso e esparso) e `CSV`. Para `CSV`, os dados devem ser densos e ter uma dimensão igual ao *número de registros \$1 tamanho do vocabulário*. O LDA pode ser treinado no modo de Arquivo ou Pipe ao usar protobufs encapsulada em recordIO, mas somente no modo de Arquivo para o formato `CSV`.
Para inferência, não há compatibilidade com os tipos de conteúdo `text/csv`, `application/json` e `application/x-recordio-protobuf`. Dados esparsos também podem ser passados para `application/json` e `application/x-recordio-protobuf`. A inferência do LDA retorna `application/json`previsões`application/x-recordio-protobuf` * ou *, que incluem o vetor `topic_mixture` para cada observação.
Para obter mais detalhes sobre os formatos de inferência e treinamento, consulte os [Cadernos de exemplo do LDA](#LDA-sample-notebooks).
## Recomendação de instâncias do EC2 para o algoritmo LDA
O LDA atualmente só é compatível com o treinamento de CPU de única instância. As instâncias de CPU são recomendadas para hospedagem/inferência.
## Cadernos de exemplo do LDA
Para ver um exemplo de caderno que mostra como treinar o algoritmo de alocação latente de Dirichlet do SageMaker AI em um conjunto de dados e, em seguida, como implantar o modelo treinado para realizar inferências sobre as combinações de tópicos em documentos de entrada, consulte [An Introduction to SageMaker AI LDA](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lda_topic_modeling/LDA-Introduction.html). Para obter instruções sobre como criar e acessar instâncias do caderno Jupyter que você pode utilizar para executar o exemplo no SageMaker AI, consulte [Instâncias de SageMaker notebook da Amazon](nbi.md). Depois de criar uma instância de caderno e abri-la, selecione a guia **Exemplos do SageMaker AI** para ver uma lista de todas os exemplos do SageMaker AI. 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 LDA funciona
O LDA do Amazon SageMaker AI é um algoritmo de aprendizado não supervisionado que tenta descrever um conjunto de observações como uma combinação de diferentes categorias. Essas categorias são a própria distribuição de probabilidade sobre os recursos. O LDA é um modelo de probabilidade generativo, o que significa que ele tenta fornecer um modelo para a distribuição de saídas e entradas com base em variáveis latentes. Isso é o contrário dos modelos discriminativos, que tentam aprender como as entradas são mapeadas para as saídas.
Use o LDA para uma variedade de tarefas, do clustering de clientes com base nas compras de produtos à análise harmônica automática de músicas. No entanto, é mais comumente associado à modelagem de tópicos em corpora de texto. As observações são chamadas de documentos. O conjunto de recursos é chamado de vocabulário. Um recurso é chamado de uma palavra. E as categorias resultantes são chamadas de tópicos.
**nota**
A lematização aumenta significativamente o desempenho e a precisão do algoritmo. Pense no pré-processamento de quaisquer dados de texto de entrada. Para obter mais informações, consulte [Raízes de palavras e lematização](https://nlp.stanford.edu/IR-book/html/htmledition/stemming-and-lemmatization-1.html).
Um modelo LDA é definido por dois parâmetros:
+ α: uma estimativa a priori sobre a probabilidade dos tópicos (em outras palavras, a frequência média da ocorrência de cada tópico em um determinado documento).
+ β: um conjunto de tópicos k, em que cada tópico recebe uma distribuição de probabilidade sobre o vocabulário usado em um corpus de documentos, também chamada de "distribuição de palavras por tópico".
O LDA é um modelo "bag-of-words", o que significa que a ordem das palavras não importa. É um modelo generativo em que cada documento é gerado palavra por palavra, pela escolha de uma combinação de tópicos θ ∼ Dirichlet (α).
Para cada palavra no documento:
+ Escolha um tópico z ∼ Multinomial(θ).
+ Escolha a distribuição de palavras por tópico correspondente, β\$1z.
+ Desenhe uma palavra w ∼ Multinomial(β\$1z).
No treinamento do modelo, o objetivo é encontrar parâmetros α e β, que maximizam a probabilidade de o corpus de textos ser gerado pelo modelo.
Os métodos mais conhecidos para estimativa do modelo LDA usam técnicas de maximização de expectativas (EM) ou amostragem de Gibbs. O LDA do Amazon SageMaker AI usa decomposição espectral de tensor. Isso traz várias vantagens:
+ **Garantias teóricas sobre os resultados**. No método EM padrão, a convergência certamente só é feita para os pontos de máximos ou mínimos locais, que geralmente são de baixa qualidade.
+ **Paralelização inconveniente**. O trabalho pode ser dividido trivialmente pelos documentos de entrada no treinamento e na inferência. As abordagens do método EM e da amostragem de Gibbs podem ser paralelizadas, mas não facilmente.
+ **Rápido**. Embora o método EM tenha um custo de iteração baixo, é suscetível a taxas lentas de convergência. A amostragem de Gibbs também está sujeita a taxas lentas, além de exigir um grande número de amostras.
Basicamente, o algoritmo de decomposição de tensor segue este processo:
1. O objetivo é calcular a decomposição espectral de um tensor **V** x **V** x **V**, que resume os momentos dos documentos no nosso corpus. **V** é o tamanho do vocabulário (em outras palavras, o número de palavras distintas em todos os documentos). Os componentes espectrais desse tensor são os parâmetros LDA α e β, que maximizam a probabilidade geral do corpus de documentos. No entanto, como o tamanho do vocabulário tende a ser grande, esse tensor **V** x **V** x **V** é grande demais para ser armazenado na memória.
1. Em vez disso, ele usa uma matriz de momento **V** x **V**, que representa uma analogia bidimensional do tensor da etapa 1, para encontrar uma matriz de ruído branco de dimensão **V** x **k**. Essa matriz pode ser usada para converter a matriz de momento **V** x **V** em uma matriz de identidade **k** x **k**. **k** é o número de tópicos no modelo.
1. Essa mesma matriz de ruído branco pode ser usada para encontrar um tensor **k** x **k** x **k** menor. Quando submetido a decomposição espectral, esse tensor conta com componentes que têm uma relação simples com os componentes do tensor **V** x **V** x **V**.
1. O método de *mínimos quadrados alternantes* é usado para decompor o tensor **k** x *k* x **k** menor. Isso fornece uma melhoria significativa em velocidade e consumo de memória. Para encontrar os parâmetros α e β, basta aplicar "ruído branco" nesses resultados, na decomposição espectral.
Depois que os parâmetros do modelo LDA são encontrados, é possível encontrar as combinações de tópicos de cada documento. Use o algoritmo Stochastic Gradient Descent para maximizar a função de probabilidade da observância de uma determinada combinação de tópicos correspondentes a esses dados.
Para aprimorar a qualidade dos tópicos, aumente o número de tópicos a ser procurados no treinamento e, em seguida, filtre os de baixa qualidade. Na verdade, isso é feito automaticamente no LDA do SageMaker AI: 25% mais tópicos são computados e apenas aqueles com antecedentes mais amplos de Dirichlet associados são exibidos. Para filtrar e analisar ainda mais os tópicos, é possível aumentar a contagem de tópicos e modificar o modelo LDA resultante da seguinte forma:
```
> import mxnet as mx
> alpha, beta = mx.ndarray.load(‘model.tar.gz’)
> # modify alpha and beta
> mx.nd.save(‘new_model.tar.gz’, [new_alpha, new_beta])
> # upload to S3 and create new SageMaker model using the console
```
Para ter mais informações sobre algoritmos para LDA e a implementação do SageMaker AI, consulte o seguinte:
+ Animashree Anandkumar, Rong Ge, Daniel Hsu, Sham M Kakade e Matus Telgarsky. *Tensor Decompositions for Learning Latent Variable Models*, Journal of Machine Learning Research, 15:2773–2832, 2014.
+ David M Blei, Andrew Y Ng e Michael I Jordan. *Latent Dirichlet Allocation*. Journal of Machine Learning Research, 3(Jan):993–1022, 2003.
+ Thomas L Griffiths e Mark Steyvers. *Finding Scientific Topics*. Proceedings of the National Academy of Sciences, 101(suppl 1):5228–5235, 2004.
+ Tamara G Kolda e Brett W Bader. *Tensor Decompositions and Applications*. SIAM Review, 51(3):455–500, 2009.
# Hiperparâmetros do LDA
Na solicitação `CreateTrainingJob`, é especificado o algoritmo de treinamento. Também é possível especificar hiperparâmetros específicos de algoritmo como mapas de string a string. A tabela a seguir lista os hiperparâmetros do algoritmo de treinamento de LDA fornecido pelo Amazon SageMaker AI. Para ter mais informações, consulte [Como o LDA funciona](lda-how-it-works.md).
| Nome do parâmetro | Descrição |
| --- | --- |
| num\$1topics | O número de tópicos que o LDA deve encontrar dentro dos dados. **Obrigatório** Valores válidos: inteiro positivo |
| feature\$1dim | O tamanho do vocabulário do corpus de documentos de entrada. **Obrigatório** Valores válidos: inteiro positivo |
| mini\$1batch\$1size | O número total de documentos no corpus de entrada. **Obrigatório** Valores válidos: inteiro positivo |
| alpha0 | Suposição inicial para o parâmetro de concentração: a soma dos elementos da estimativa a priori Dirichlet. Valores menores têm mais probabilidade de gerar combinações esparsas de tópicos, e os valores maiores que 1,0 produzem mais combinações uniformes. **Opcional** Valores válidos: flutuante positivo Valor padrão: 1.0 |
| max\$1restarts | O número de reinicializações a ser executadas durante a fase de decomposição espectral de mínimos quadrados alternantes (ALS) do algoritmo. Pode ser usado para encontrar pontos de mínimos locais de melhor qualidade, mas normalmente não deve ser ajustado. **Opcional** Valores válidos: inteiro positivo Valor padrão: 10 |
| max\$1iterations | O número máximo de iterações a ser executadas durante a fase ALS do algoritmo. Pode ser usado para encontrar pontos de mínimos de melhor qualidade, mas normalmente não deve ser ajustado. **Opcional** Valores válidos: inteiro positivo Valor padrão: 1000 |
| tol | Tolerância fixada de erro para a fase ALS do algoritmo. Pode ser usado para encontrar pontos de mínimos de melhor qualidade, mas normalmente não deve ser ajustado. **Opcional** Valores válidos: flutuante positivo Valor padrão: 1e-8 |
# Ajustar um modelo LDA
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.
O LDA é um algoritmo de modelagem de tópico não supervisionado que tenta descrever um conjunto de observações (documentos) como uma mistura de diferentes categorias (tópicos). A métrica "verossimilhança de log por palavra" (PWLL) mede a probabilidade de que um conjunto de tópicos aprendidos (um modelo LDA) descreva com precisão um conjunto de dados do documento de teste. Valores maiores de PWLL indicam que é mais provável que os dados de teste sejam descritos pelo modelo LDA.
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 LDA
O algoritmo LDA informa sobre uma única métrica durante o treinamento: `test:pwll`. Ao ajustar um modelo, escolha essa métrica como a métrica objetiva.
| Nome da métrica | Descrição | Direção de otimização |
| --- | --- | --- |
| test:pwll | Verossimilhança de log por palavra no conjunto de dados de teste. A probabilidade de o conjunto de dados de teste ser descrito com precisão pelo modelo LDA aprendido. | Maximizar |
## Hiperparâmetros ajustáveis do algoritmo LDA
Você pode ajustar os seguintes hiperparâmetros para o algoritmo LDA. Ambos os hiperparâmetros, `alpha0` e `num_topics` , podem afetar a métrica objetiva do algoritmo LDA (`test:pwll`). Se você ainda não conhece os valores ideais para esses hiperparâmetros, que maximizam a verossimilhança de log por palavra e produzem um modelo LDA preciso, o ajuste automático do modelo pode ajudar a encontrá-los.
| Nome do parâmetro | Tipo de parâmetro | Intervalos recomendados |
| --- | --- | --- |
| alpha0 | ContinuousParameterRanges | MinValue: 0.1, MaxValue: 10 |
| num\$1topics | IntegerParameterRanges | MinValue: 1, MaxValue: 150 |
# Algoritmo de Modelo de tópicos neurais (NTM)
O Amazon SageMaker AI NTM é um algoritmo de aprendizado não supervisionado usado para organizar um corpus de documentos em *tópicos* que contêm agrupamentos de palavras com base em sua distribuição estatística. Por exemplo, os documentos que contêm ocorrências frequentes de palavras como "bicicleta", "carro", "trem", "quilometragem" e "velocidade" provavelmente compartilham um tópico "transporte". A modelagem de tópicos pode ser usada para classificar ou resumir documentos com base nos tópicos detectados ou para recuperar informações ou recomendar conteúdo com base em semelhanças de tópicos. Os tópicos de documentos que o NTM aprende são caracterizados como uma *representação latente*, pois são inferidos das distribuições de palavras observadas no corpus. A semântica dos tópicos é geralmente inferida por meio do exame das palavras melhor classificadas que eles contêm. Por se tratar de um método não supervisionado, somente o número de tópicos é predeterminado, não os tópicos em si. Além disso, não há garantias de que os tópicos estejam alinhados com o modo humano de naturalmente categorizar documentos.
Com a modelagem de tópicos, é possível visualizar o conteúdo de um grande corpus de documentos quanto aos tópicos aprendidos. Os documentos relevantes para cada tópico podem ser indexados ou pesquisados com base nos seus rótulos de tópicos flexíveis. As representações latentes dos documentos também podem ser usadas para encontrar documentos semelhantes no espaço do tópico. Além disso, é possível usar as representações latentes dos documentos aprendidos pelo modelo de tópico como dados de entrada em outro algoritmo supervisionado, como um classificador de documentos. Como essas representações devem capturar a semântica dos documentos subjacentes, o esperado é que o desempenho dos algoritmos parcialmente baseados nelas seja melhor do que o dos algoritmos baseados somente em atributos lexicais.
Embora você possa usar os algoritmos Amazon SageMaker AI NTM e LDA para modelagem de tópicos, eles são algoritmos distintos e pode-se esperar que produzam resultados diferentes nos mesmos dados de entrada.
Para obter mais informações sobre a matemática subjacente do NTM, consulte este artigo sobre [inferência de variação neural para processamento de texto](https://arxiv.org/pdf/1511.06038.pdf).
**Topics**
+ [Interface de entrada/saída para o algoritmo NTM](#NTM-inputoutput)
+ [Recomendações de instâncias do EC2 para o algoritmo NTM](#NTM-instances)
+ [Cadernos de amostra do NTM](#NTM-sample-notebooks)
+ [Hiperparâmetros do NTM](ntm_hyperparameters.md)
+ [Ajustar um modelo NTM](ntm-tuning.md)
+ [Formatos de resposta do NTM](ntm-in-formats.md)
## Interface de entrada/saída para o algoritmo NTM
O Amazon SageMaker AI Neural Topic Model oferece suporte a quatro canais de dados: treinamento, validação, teste e auxiliar. Os canais de dados de validação, teste e auxiliar são opcionais. Se você especificar qualquer um desses canais opcionais, defina o valor do parâmetro `S3DataDistributionType` para eles como `FullyReplicated`. Se você fornecer dados de validação, a perda sobre esses dados será registrada a cada epoch, e o modelo interromperá o treinamento assim que detectar que a perda de validação não está melhorando. Se você não fornecê-los, o algoritmo será interrompido antecipadamente com base nos dados de treinamento, mas isso pode ser menos eficiente. Se dados de teste forem fornecidos, o algoritmo relatará a perda de teste do modelo final.
Os canais de dados de treinamento, validação e teste para o NTM oferecem apoio aos formatos de arquivo `recordIO-wrapped-protobuf` (denso e esparso) e `CSV`. Para o formato `CSV`, cada linha deve ser representada densamente com contagens de zero para palavras não presentes no documento correspondente e ter uma dimensão igual a: (número de registros) \$1 (tamanho do vocabulário). É possível usar o modo de Arquivo ou de Pipe para treinar modelos em dados formatados como `recordIO-wrapped-protobuf` ou `CSV`. O canal auxiliar é usado para fornecer um arquivo de texto que contém vocabulário. Ao fornecer o arquivo de vocabulário, os usuários podem ver as principais palavras de cada um dos tópicos impressos no registro em vez de seus números inteiros. IDs Ter o arquivo de vocabulário também permite que o NTM calcule as pontuações WETC (Coerência de tópicos de incorporação de palavras), uma nova métrica exibida no log que captura a semelhança entre as principais palavras em cada tópico de forma eficaz. O `ContentType` para o canal auxiliar é`text/plain`, com cada linha contendo uma única palavra, na ordem correspondente ao número inteiro IDs fornecido nos dados. O arquivo de vocabulário deve ser nomeado como `vocab.txt` e, atualmente, apenas a codificação UTF-8 é compatível.
Para inferência, há compatibilidade com os tipos de conteúdo `text/csv`, `application/json`, `application/jsonlines` e `application/x-recordio-protobuf`. Dados esparsos também podem ser passados para `application/json` e `application/x-recordio-protobuf`. A inferência do NTM retorna `application/json`predições`application/x-recordio-protobuf` * ou *, que incluem o vetor `topic_weights` para cada observação.
Consulte a [postagem do blog](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-neural-topic-model-now-supports-auxiliary-vocabulary-channel-new-topic-evaluation-metrics-and-training-subsampling/) para obter mais detalhes sobre como usar o canal auxiliar e as pontuações do WETC. Para obter mais informações sobre como calcular a pontuação de WETC, consulte [Modelagem de tópicos neurais com reconhecimento de coerência](https://arxiv.org/pdf/1809.02687.pdf). Usamos o WETC em pares descrito neste paper para o Amazon SageMaker AI Neural Topic Model.
Para obter mais informações sobre formatos de arquivo de entrada e saída, consulte [Formatos de resposta do NTM](ntm-in-formats.md) para inferência e os [Cadernos de amostra do NTM](#NTM-sample-notebooks).
## Recomendações de instâncias do EC2 para o algoritmo NTM
O treinamento do NTM é compatível com os tipos de instância de GPU e CPU. Recomendamos as instâncias de GPU, mas os custos de treinamento podem ser menores em instâncias de CPU para determinadas workloads. Para inferência, as instâncias de CPU já são o bastante. O treinamento NTM oferece apoio às famílias de instâncias de GPU P2, P3, G4dn e G5 para treinamento e inferência.
## Cadernos de amostra do NTM
Para obter um exemplo de caderno que usa o algoritmo SageMaker AI NTM para descobrir tópicos em documentos de uma fonte de dados sintética em que as distribuições de tópicos são conhecidas, consulte a [Introdução à funcionalidade básica](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/ntm_synthetic/ntm_synthetic.html) do NTM. 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**.
# Hiperparâmetros do NTM
A tabela a seguir lista os hiperparâmetros que você pode definir para o algoritmo Amazon SageMaker AI Neural Topic Model (NTM).
| Nome do parâmetro | Description |
| --- | --- |
| `feature_dim` | O tamanho do vocabulário do conjunto de dados. **Obrigatório** Valores válidos: inteiro positivo (mínimo: 1; máximo: 1.000.000) |
| num\$1topics | O número de tópicos obrigatórios. **Obrigatório** Valores válidos: inteiro positivo (mínimo: 2; máximo: 1000) |
| batch\$1norm | Se a normalização de lote deve ser usada durante o treinamento. **Opcional** Valores válidos: *true* ou *false* Valor padrão: *false* |
| clip\$1gradient | A magnitude máxima de cada componente de gradiente. **Opcional** Valores válidos: flutuante (mínimo: 1e-3) Valor padrão: infinito |
| encoder\$1layers | O número de camadas no codificador e o tamanho da saída de cada camada. Quando definido como *auto*, o algoritmo usa duas camadas com 3 vezes o tamanho de `num_topics` e 2 vezes o tamanho de `num_topics` respectivamente. **Opcional** Valores válidos: lista separada por vírgulas de inteiros positivos ou *auto* Valor padrão: *auto* |
| encoder\$1layers\$1activation | A função de ativação a ser usada nos codificadores de camadas. **Opcional** Valores válidos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/ntm_hyperparameters.html) Valor padrão: `sigmoid` |
| epochs | O número máximo de passagens nos dados de treinamento. **Opcional** Valores válidos: inteiro positivo (mínimo: 1) Valor padrão: 50 |
| learning\$1rate | A taxa de aprendizado do otimizador. **Opcional** Valores válidos: flutuante (mínimo: 1e-6; máximo: 1,0) Valor padrão: 0.001 |
| mini\$1batch\$1size | O número de exemplos em cada minilote. **Opcional** Valores válidos: inteiro positivo (mínimo: 1; máximo: 10000) Valor padrão: 256 |
| num\$1patience\$1epochs | O número de epochs sucessivos sobre o qual cada critério de interrupção precoce é avaliado. A interrupção precoce é acionada quando a mudança na função de perda cai abaixo do `tolerance` especificado no último `num_patience_epochs` número de epochs. Para desativar a interrupção precoce, defina `num_patience_epochs` como um valor maior que `epochs`. **Opcional** Valores válidos: inteiro positivo (mínimo: 1) Valor padrão: 3 |
| optimizer | O otimizador a ser usado para o treinamento. **Opcional** Valores válidos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/ntm_hyperparameters.html) Valor padrão: `adadelta` |
| rescale\$1gradient | O fator de redimensionamento do gradiente. **Opcional** Valores válidos: flutuante (mínimo: 1e-3; máximo: 1,0) Valor padrão: 1.0 |
| sub\$1sample | A fração dos dados de treinamento da qual obter uma amostra para treinamento por epoch. **Opcional** Valores válidos: flutuante (mínimo: 0,0; máximo: 1,0) Valor padrão: 1.0 |
| tolerance | A mudança relativa máxima na função de perda. A interrupção precoce é acionada quando a mudança na função de perda cai abaixo desse valor no último `num_patience_epochs` número de epochs. **Opcional** Valores válidos: flutuante (mínimo: 1e-6; máximo: 0,1) Valor padrão: 0.001 |
| weight\$1decay | O coeficiente de degradação do peso. Adiciona regularização L2. **Opcional** Valores válidos: flutuante (mínimo: 0,0; máximo: 1,0) Valor padrão: 0.0 |
# Ajustar um modelo NTM
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.
O Amazon SageMaker AI NTM é um algoritmo de aprendizado não supervisionado que aprende representações latentes de grandes coleções de dados discretos, como um corpus de documentos. Representações latentes usam variáveis inferidas que não são medidas diretamente para modelar as observações em um conjunto de dados. O ajuste automático de modelo no NTM ajuda a encontrar o modelo que minimiza a perda sobre os dados de treinamento ou validação. A *perda de treinamento* mede o quão bem o modelo se encaixa nos dados de treinamento. A *perda de validação* mede o quão bem o modelo pode generalizar para os dados nos quais ele não é treinado. Uma baixa perda de treinamento indica que um modelo é uma boa opção para os dados de treinamento. Uma baixa perda de validação indica que um modelo não causou sobreajuste nos dados de treinamento e, portanto, deve ser capaz de modelar com sucesso os documentos nos quais não foi treinado. Normalmente, é preferível que ambas as perdas sejam pequenas. No entanto, minimizar a perda de treinamento em excesso pode resultar em um superajuste e aumentar a perda de validação, o que reduziria a generalidade do modelo.
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 NTM
O algoritmo NTM relata uma única métrica que é calculada durante o treinamento: `validation:total_loss`. A perda total é a soma da perda de reconstrução e da divergência de Kullback-Leibler. Ao ajustar os valores de hiperparâmetros, escolha essa métrica como o objetivo.
| Nome da métrica | Description | Direção de otimização |
| --- | --- | --- |
| validation:total\$1loss | Perda total no conjunto de validação | Minimizar |
## Hyperparameters ajustáveis do NTM
Você pode ajustar os seguintes hiperparâmetros para o algoritmo NTM: Normalmente, configurar valores `mini_batch_size` baixos e `learning_rate` pequenos resulta em perdas de validação mais baixas, embora possa exigir maior tempo de treinamento. Baixas perdas de validação não necessariamente produzem mais tópicos coerentes conforme interpretados pelos seres humanos. O efeito de outros hiperparâmetros na perda de treinamento e validação pode variar dependendo do conjunto de dados. Para ver quais valores são compatíveis, consulte [Hiperparâmetros do NTM](ntm_hyperparameters.md).
| Nome do parâmetro | Tipo de parâmetro | Intervalos recomendados |
| --- | --- | --- |
| encoder\$1layers\$1activation | CategoricalParameterRanges | ['sigmoid', 'tanh', 'relu'] |
| learning\$1rate | ContinuousParameterRange | MinValue: 1e-4, MaxValue: 0,1 |
| mini\$1batch\$1size | IntegerParameterRanges | MinValue: 16, :2048 MaxValue |
| optimizer | CategoricalParameterRanges | ['sgd', 'adam', 'adadelta'] |
| rescale\$1gradient | ContinuousParameterRange | MinValue: 0,1, MaxValue 1,0 |
| weight\$1decay | ContinuousParameterRange | MinValue: 0,0, MaxValue 1,0 |
# Formatos de resposta do NTM
Todos os algoritmos integrados do Amazon SageMaker AI aderem ao formato comum de inferência de entrada descrito em [Formatos de dados comuns - Inferência](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html). Este tópico contém uma lista dos formatos de saída disponíveis para o algoritmo SageMaker AI NTM.
## Formato de resposta JSON
```
{
"predictions": [
{"topic_weights": [0.02, 0.1, 0,...]},
{"topic_weights": [0.25, 0.067, 0,...]}
]
}
```
## Formato de resposta JSONLINES
```
{"topic_weights": [0.02, 0.1, 0,...]}
{"topic_weights": [0.25, 0.067, 0,...]}
```
## Formato de resposta RECORDIO
```
[
Record = {
features = {},
label = {
'topic_weights': {
keys: [],
values: [0.25, 0.067, 0, ...] # float32
}
}
},
Record = {
features = {},
label = {
'topic_weights': {
keys: [],
values: [0.25, 0.067, 0, ...] # float32
}
}
}
]
```
# Algoritmo Object2Vec
O algoritmo Amazon SageMaker AI Object2Vec é um algoritmo de incorporação neural de uso geral que é altamente personalizável. Ele pode aprender incorporações densas de baixa dimensão de objetos de alta dimensão. As incorporações são aprendidas de uma maneira que preserva a semântica do relacionamento entre pares de objetos no espaço original no espaço de incorporação. É possível usar as incorporações aprendidas para calcular com eficiência os vizinhos mais próximos de objetos e para visualizar clusters naturais de objetos relacionados em espaços de baixa dimensão, por exemplo. Você também pode usar as incorporações como atributos dos objetos correspondentes em tarefas posteriores supervisionadas, como classificação ou regressão.
O Object2Vec generaliza a conhecida técnica de incorporação Word2Vec para palavras que é otimizada na IA. SageMaker [BlazingText algoritmo](blazingtext.md) Para uma postagem no blog que discute como aplicar o Object2Vec a alguns casos de uso práticos, consulte Introdução [ao](https://aws.amazon.com/blogs/machine-learning/introduction-to-amazon-sagemaker-object2vec/) Amazon AI Object2Vec. SageMaker
**Topics**
+ [Interface de E/S para o algoritmo Object2Vec](#object2vec-inputoutput)
+ [Recomendações de instâncias do EC2 para o algoritmo Object2Vec](#object2vec--instances)
+ [Cadernos de amostra para Object2Vec](#object2vec-sample-notebooks)
+ [Como funciona o algoritmo Object2Vec](object2vec-howitworks.md)
+ [Hiperparâmetros de Object2Vec](object2vec-hyperparameters.md)
+ [Ajustar um modelo Object2Vec](object2vec-tuning.md)
+ [Formatos de dados para treinamento em Object2Vec](object2vec-training-formats.md)
+ [Formatos de dados para inferência em Object2Vec](object2vec-inference-formats.md)
+ [Incorporações de codificadores para Object2Vec](object2vec-encoder-embeddings.md)
## Interface de E/S para o algoritmo Object2Vec
Você pode usar o algoritmo Object2Vec em diversos tipos de dados de entrada, incluindo os seguintes exemplos:
| Tipos de dados de entrada | Exemplo |
| --- | --- |
| Pares de frase-frase | “Um jogo de futebol com vários homens jogando.” e “Alguns homens estão praticando um esporte”. |
| Pares de rótulo-sequência | As tags de gênero do filme "Titanic", como "Romance" e "Drama", e sua breve descrição: "Titanic, de James Cameron, é um romance épico repleto de ação sobre a malfadada viagem inaugural do R.M.S. Titanic. Ele foi o transatlântico mais luxuoso de sua era, um navio dos sonhos que, finalmente, levou mais de 1.500 pessoas à morte nas águas geladas do Atlântico Norte na madrugada de 15 de abril de 1912." |
| Pares de cliente-cliente | O ID do cliente de Jane e o ID de cliente Jackie. |
| Pares de produto-produto | O ID do produto do futebol e o ID do produto de basquete. |
| Pares de item-usuário de revisão de item | Um ID do usuário e os itens que ela comprou, como apple, pereira e laranja. |
Para transformar os dados de entrada em formatos compatíveis, eles devem ser preprocessados. Atualmente, o algoritmo Object2Vec oferece apoio de forma nativa a dois tipos de entrada:
+ Um token discreto, que é representado como lista de um único `integer-id`. Por exemplo, .`[10]`
+ Uma sequências de tokens discretos, que é representado como lista de `integer-ids`. Por exemplo, .`[0,12,10,13]`
O objeto em cada par pode ser assimétrico. Por exemplo, os pares podem ser (token, sequência) ou (token, token) ou (sequência, sequência). Para entradas de token, o algoritmo oferece apoio a incorporações simples como codificadores compatíveis. Para sequências de vetores de token, o algoritmo oferece apoio para os seguintes codificadores:
+ Incorporações em pool médio
+ Redes neurais convolucionais hierárquicas (), CNNs
+ Memória bidirecional de longo prazo (Bi) de várias camadas LSTMs
O rótulo de entrada para cada par pode ser um dos seguintes:
+ Um rótulo categórico que expressa a relação entre os objetos no par
+ Uma pontuação que expressa a intensidade da semelhança entre os dois objetos
Para rótulos categóricos usados na classificação, o algoritmo oferece apoio para a função de perda de entropia cruzada. Para classificações/rótulos baseados em pontuação usados na regressão, o algoritmo oferece apoio para a função de perda de MSE (erro quadrático médio). Especifique essas funções de perda com o hiperparâmetro `output_layer` ao criar o trabalho de treinamento de modelo.
## Recomendações de instâncias do EC2 para o algoritmo Object2Vec
O tipo de instância do Amazon Elastic Compute Cloud (Amazon EC2) que você usa depende do fato de você estar treinando ou executando inferência.
Ao treinar um modelo usando o algoritmo Object2Vec em uma CPU, comece com uma instância ml.m5.2xlarge. Para treinar em uma GPU, comece com uma instância ml.p2.xlarge. Se o treinamento demorar muito nessa instância, você poderá usar uma instância maior. Atualmente, o algoritmo Object2Vec só pode treinar em uma única máquina. No entanto, ele oferece suporte para vários GPUs. O Object2Vec oferece apoio às famílias de instâncias de GPU P2, P3, G4dn e G5 para treinamento e inferência.
Para inferência com um modelo Object2Vec treinado com uma rede neural profunda, recomendamos o uso de instância de GPU ml.p3.2xlarge. Devido à falta de memória de GPU, a variável de ambiente `INFERENCE_PREFERRED_MODE` pode ser especificada para otimização se a rede de inferência [Otimização de GPU: classificação ou regressão](object2vec-inference-formats.md#object2vec-inference-gpu-optimize-classification) ou [Otimização de GPU: incorporações de codificador](object2vec-encoder-embeddings.md#object2vec-inference-gpu-optimize-encoder-embeddings) for carregada na GPU.
## Cadernos de amostra para Object2Vec
+ [Como usar o Object2Vec para codificar frases em incorporações de comprimento fixo](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/object2vec_sentence_similarity/object2vec_sentence_similarity.html)
# Como funciona o algoritmo Object2Vec
Ao usar o algoritmo Amazon SageMaker AI Object2Vec, você segue o fluxo de trabalho padrão: processa os dados, treina o modelo e produz inferências.
**Topics**
+ [Etapa 1: Processar dados](#object2vec-step-1-data-preprocessing)
+ [Etapa 2: Treinar um modelo](#object2vec-step-2-training-model)
+ [Etapa 3: produzir inferências](#object2vec-step-3-inference)
## Etapa 1: Processar dados
Durante o pré-processamento, converta os dados no formato de arquivo de texto [JSON Lines](http://jsonlines.org/) especificado em [Formatos de dados para treinamento em Object2Vec](object2vec-training-formats.md). Além disso, para obter a maior precisão durante o treinamento, embaralhe aleatoriamente os dados antes de inseri-los no modelo. Como você gera permutações aleatórias depende do idioma. Para Python, use `np.random.shuffle`. Para Unix, use `shuf`.
## Etapa 2: Treinar um modelo
O algoritmo SageMaker AI Object2Vec tem os seguintes componentes principais:
+ **Dois canais de entrada**: Os canais de entrada usam um par de objetos do mesmo tipo ou de tipos diferentes como entradas e os transferem para codificadores independentes e personalizáveis.
+ **Dois codificadores**: Os dois codificadores enc0 e enc1 convertem cada objeto em um vetor de incorporação de tamanho fixo. As incorporações codificadas dos objetos no par, que são então transmitidas para um comparador.
+ **Um comparador**: O comparador compara as incorporações de diferentes maneiras e gera pontuações que indicam a força do relacionamento entre os objetos emparelhados. Na pontuação de saída para um par de frases. Por exemplo, 1 indica uma forte relação entre um par de frase e 0 representa um relacionamento fraco.
Durante o treinamento, o algoritmo aceita pares de objetos e seus rótulos de relacionamento ou pontuações como entradas. Os objetos em cada par pode ser de tipos diferentes, como descrito anteriormente. Se as entradas para os dois codificadores forem compostas pelas mesmas unidades de nível de token, você poderá usar uma camada de incorporação de token compartilhada definindo o hiperparâmetro `tied_token_embedding_weight` para quando `True` criar a tarefa de treinamento. Isso é possível, por exemplo, ao comparar sentenças que possuem unidades de nível de token de palavra. Para gerar amostras negativas em uma taxa especificada, defina o hiperparâmetro `negative_sampling_rate` para a proporção desejada de amostras negativas para positivas. Esse hiperparâmetro agiliza o aprendizado de como diferenciar as amostras positivas observadas nos dados de treinamento e as amostras negativas que provavelmente não serão observadas.
Os pares de objetos são transmitidos por meio de codificadores personalizáveis e independentes que são compatíveis com os tipos de entrada dos objetos correspondentes. Os codificadores convertem cada objeto em um par em um vetor de incorporação de tamanho fixo e comprimento igual. O par de vetores é passado para um operador comparador, que monta os vetores em um único vetor usando o valor especificado no hiperparâmetro `comparator_list`. O vetor montado, em seguida, passa por uma camada multilayer perceptron (MLP), que produz uma saída que compara a função de perda com os rótulos que você forneceu. Essa comparação avalia a intensidade do relacionamento entre os objetos no par conforme previsto pelo modelo. A figura a seguir mostra esse fluxo de trabalho.
![\[Arquitetura do algoritmo Object2Vec de entradas de dados a pontuações\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/object2vec-training-image.png)
## Etapa 3: produzir inferências
Depois que o modelo for treinado, você poderá usar o codificador treinado para pré-processar objetos de entrada ou para executar dois tipos de inferência:
+ Para converter objetos de entrada singulares em incorporações de tamanho fixo usando o codificador correspondente
+ Para prever o rótulo de relacionamento ou a pontuação entre um par de objetos de entrada
O servidor de inferência calcula automaticamente qual dos tipos é solicitado com base nos dados de entrada. Para ter as incorporações como saída, forneça apenas uma entrada. Para prever o rótulo ou a pontuação do relacionamento, forneça as duas entradas no par.
# Hiperparâmetros de Object2Vec
Na solicitação `CreateTrainingJob`, é especificado o algoritmo de treinamento. Você também pode especificar hiperparâmetros específicos do algoritmo como mapas. string-to-string A tabela a seguir lista os hiperparâmetros do algoritmo de treinamento do Object2Vec.
| Nome do parâmetro | Description |
| --- | --- |
| enc0\$1max\$1seq\$1len | O tamanho máximo da sequência do codificador enc0. **Obrigatório** Valores válidos: 1 ≤ inteiro ≤ 5000 |
| enc0\$1vocab\$1size | O tamanho do vocabulário de tokens enc0. **Obrigatório** Valores válidos: 2 ≤ inteiro ≤ 3000000 |
| bucket\$1width | A diferença permitida entre o tamanho da sequência de dados quando a geração de buckets é habilitada. Para habilitar buckets, especifique um valor diferente de zero para esse parâmetro. **Opcional** Valores válidos: 0 ≤ inteiro ≤ 100 Valor padrão: 0 (sem geração de buckets) |
| comparator\$1list | Uma lista usada para personalizar a maneira como duas incorporações são comparados. A camada de operador do comparador Object2Vec usa as codificações de ambos os codificadores como entradas e saídas de um único vetor. Este vetor é uma concatenação de subvetores. Os valores da cadeia de caracteres transmitidas para a `comparator_list` e a ordem na qual elas são transmitidas determina como esses subvetores são montados. Por exemplo, se `comparator_list="hadamard, concat"`, o operador comparador constrói o vetor concatenando o produto de Hadamard de duas codificações e a concatenação de duas codificações. Se, por outro lado, `comparator_list="hadamard"`, o operador comparador constrói o vetor como produto do hadamard de apenas duas codificações. **Opcional** Valores válidos: uma string que contém qualquer combinação dos nomes dos três operadores binários: `hadamard`, `concat`, ou `abs_diff`. O algoritmo Object2Vec atualmente exige que as duas codificações vetoriais tenham a mesma dimensão. Esses operadores produzem os subvetores da seguinte maneira: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor padrão: `"hadamard, concat, abs_diff"` |
| dropout | A probabilidade de abandono para camadas de rede. O *abandono* é uma forma de regularização usada em redes neurais que reduz o sobreajuste ao remover neurônios codependentes. **Opcional** Valores válidos: 0,0 ≤ flutuante ≤ 1,0 Valor padrão: 0.0 |
| early\$1stopping\$1patience | O número de epochs consecutivos sem melhoria permitida antes que a interrupção precoce seja aplicada. A melhoria é definida pelo hiperparâmetro `early_stopping_tolerance`. **Opcional** Valores válidos: 1 ≤ inteiro ≤ 5 Valor padrão: 3 |
| early\$1stopping\$1tolerance | A redução na função de perda que um algoritmo deve alcançar entre epochs consecutivos para evitar a interrupção precoce após o número de epochs consecutivos especificado no hiperparâmetro `early_stopping_patience` ser concluído. **Opcional** Valores válidos: 0,000001 ≤ flutuante ≤ 0,1 Valor padrão: 0,01 |
| enc\$1dim | A dimensão da saída da camada de incorporação. **Opcional** Valores válidos: 4 ≤ inteiro ≤ 10000 Valor padrão: 4096 |
| enc0\$1network | O modelo de rede para o codificador enc0. **Opcional** Valores válidos: `hcnn`, `bilstm` ou `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor padrão: `hcnn` |
| enc0\$1cnn\$1filter\$1width | A largura do filtro do codificador enc0 rede neural convolucional (CNN). **Condicional** Valores válidos: 1 ≤ inteiro ≤ 9 Valor padrão: 3 |
| enc0\$1freeze\$1pretrained\$1embedding | Se os pesos de incorporações pré-treinadas de enc0 devem ou não ser congelados. **Condicional** Valores válidos: `True` ou `False` Valor padrão: `True` |
| enc0\$1layers | O número de camadas no codificador enc0. **Condicional** Valores válidos: `auto` ou 1 ≤ inteiro ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor padrão: `auto` |
| enc0\$1pretrained\$1embedding\$1file | O nome do arquivo de incorporação de token enc0 pré-treinado no canal de dados auxiliar. **Condicional** Valores válidos: string com caracteres alfanuméricos, sublinhado ou ponto final. [A-Za-z0-9\$1.\$1\$1] Valor padrão: "" (string vazia) |
| enc0\$1token\$1embedding\$1dim | A dimensão de saída da camada de incorporação de token enc0. **Condicional** Valores válidos: 2 ≤ inteiro ≤ 1000 Valor padrão: 300 |
| enc0\$1vocab\$1file | O arquivo de vocabulário para mapear vetores de incorporação de tokens enc0 pré-treinados ao vocabulário numérico. IDs **Condicional** Valores válidos: string com caracteres alfanuméricos, sublinhado ou ponto final. [A-Za-z0-9\$1.\$1\$1] Valor padrão: "" (string vazia) |
| enc1\$1network | O modelo de rede para o codificador enc1. Se você quiser que o codificador enc1 use o mesmo modelo de rede que o enc0, incluindo os valores do hiperparâmetro, defina o valor como `enc0`. Mesmo quando as redes dos codificadores enc0 e enc1 tiverem arquiteturas simétricas, você não poderá compartilhar valores de parâmetros para essas redes. **Opcional** Valores válidos: `enc0`, `hcnn`, `bilstm` ou `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor padrão: `enc0` |
| enc1\$1cnn\$1filter\$1width | A largura do filtro do codificador enc1 da CNN. **Condicional** Valores válidos: 1 ≤ inteiro ≤ 9 Valor padrão: 3 |
| enc1\$1freeze\$1pretrained\$1embedding | Se os pesos de incorporações pré-treinadas de enc1 devem ou não ser congelados. **Condicional** Valores válidos: `True` ou `False` Valor padrão: `True` |
| enc1\$1layers | O número de camadas no codificador enc1. **Condicional** Valores válidos: `auto` ou 1 ≤ inteiro ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor padrão: `auto` |
| enc1\$1max\$1seq\$1len | O tamanho máximo da sequência do codificador enc1. **Condicional** Valores válidos: 1 ≤ inteiro ≤ 5000 |
| enc1\$1pretrained\$1embedding\$1file | O nome de incorporação de token enc1 pré-treinado no canal de dados auxiliar. **Condicional** Valores válidos: string com caracteres alfanuméricos, sublinhado ou ponto final. [A-Za-z0-9\$1.\$1\$1] Valor padrão: "" (string vazia) |
| enc1\$1token\$1embedding\$1dim | A dimensão de saída da camada de incorporação de token enc1. **Condicional** Valores válidos: 2 ≤ inteiro ≤ 1000 Valor padrão: 300 |
| enc1\$1vocab\$1file | O arquivo de vocabulário para mapear incorporações de tokens enc1 pré-treinados ao vocabulário. IDs **Condicional** Valores válidos: string com caracteres alfanuméricos, sublinhado ou ponto final. [A-Za-z0-9\$1.\$1\$1] Valor padrão: "" (string vazia) |
| enc1\$1vocab\$1size | O tamanho do vocabulário de tokens enc0. **Condicional** Valores válidos: 2 ≤ inteiro ≤ 3000000 |
| epochs | O número de epochs a serem executados para treinamento. **Opcional** Valores válidos: 1 ≤ inteiro ≤ 100 Valor padrão: 30 |
| learning\$1rate | A taxa de aprendizado para treinamento. **Opcional** Valores válidos: 1,0E-6 ≤ flutuante ≤ 1,0 Valor padrão: 0,0004 |
| mini\$1batch\$1size | O tamanho do lote em que o conjunto de dados é dividido em um `optimizer` durante o treinamento. **Opcional** Valores válidos: 1 ≤ inteiro ≤ 10000 Valor padrão: 32 |
| mlp\$1activation | O tipo de função de ativação para a camada MLP (multilayer perceptron). **Opcional** Valores válidos: `tanh`, `relu` ou `linear` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor padrão: `linear` |
| mlp\$1dim | A dimensão da saída das camadas MLP. **Opcional** Valores válidos: 2 ≤ inteiro ≤ 10000 Valor padrão: 512 |
| mlp\$1layers | O número de camadas MLP na rede. **Opcional** Valores válidos: 0 ≤ inteiro ≤ 10 Valor padrão: 2 |
| negative\$1sampling\$1rate | O coeficiente de amostras negativas, gerada para auxiliar no treinamento do algoritmo, para amostras positivas fornecidas pelos usuários. Amostras negativas representam dados que são improváveis de ocorrer na realidade e são rotulados negativamente para treinamento. Eles facilitam o treinamento de um modelo para diferenciar as amostras positivas observadas das amostras negativas que não são. Para especificar a proporção de amostras negativas para amostras positivas usadas para treinamento, defina o valor como um inteiro positivo. Por exemplo, se você treinar o algoritmo em dados de entrada nos quais todas as amostras são positivas e configuradas `negative_sampling_rate` como 2, o algoritmo Object2Vec gera internamente duas amostras negativas por amostra positiva. Se você não quiser gerar ou usar amostras negativas durante o treinamento, defina o valor como 0. **Opcional** Valores válidos: 0 ≤ inteiro Valor padrão: 0 (desativado) |
| num\$1classes | O número de classes para treinamento de classificação. A Amazon SageMaker AI ignora esse hiperparâmetro para problemas de regressão. **Opcional** Valores válidos: 2 ≤ inteiro ≤ 30 Valor padrão: 2 |
| optimizer | O tipo de otimizador. **Opcional** Valores válidos: `adadelta`, `adagrad`, `adam`, `sgd` ou `rmsprop`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor padrão: `adam` |
| output\$1layer | O tipo de camada de saída em que você especifica que a tarefa é regressão ou classificação. **Opcional** Valores válidos: `softmax` ou `mean_squared_error` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor padrão: `softmax` |
| tied\$1token\$1embedding\$1weight | Se deve usar uma camada de incorporação compartilhada para os dois codificadores. Se as entradas dos dois codificadores usarem as mesmas unidades de nível de token, use uma camada de incorporação de token compartilhado. Por exemplo, para um conjunto de documentos, se um codificador codifica frases e outro codifica documentos inteiros, você pode usar uma camada de incorporação de token compartilhado. Isso porque ambas as sentenças e documentos são compostos de tokens de palavras do mesmo vocabulário. **Opcional** Valores válidos: `True` ou `False` Valor padrão: `False` |
| token\$1embedding\$1storage\$1type | O modo de atualização de gradiente usado durante o treinamento: quando o modo `dense` é usado, o otimizador calcula a matriz de gradiente completa para a camada de incorporação de token, mesmo que a maioria das linhas do gradiente seja de valor zero. Quando o modo `sparse` é usado, o otimizador só armazena linhas do gradiente que estão sendo usadas no mini-lote. Se você quiser que o algoritmo realize atualizações de gradiente lento, que calculam os gradientes apenas nas linhas diferentes de zero e que aceleram o treinamento, especifique `row_sparse`. Definindo o valor como `row_sparse` para restringir os valores disponíveis para outros hiperparâmetros, da seguinte maneira: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/object2vec-hyperparameters.html) **Opcional** Valores válidos: `dense` ou `row_sparse` Valor padrão: `dense` |
| weight\$1decay | O parâmetro de degradação de peso usado para otimização. **Opcional** Valores válidos: 0 ≤ flutuante ≤ 10000 Valor padrão: 0 (sem degradação) |
# Ajustar um modelo Object2Vec
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. Para a métrica objetiva, você usa uma das 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 Object2Vec
O algoritmo Object2Vec possui métricas de classificação e regressão. O tipo de `output_layer` determina qual métrica você pode usar para ajuste modelo automático.
### Métricas de regressor calculadas pelo algoritmo Object2Vec
O algoritmo relata uma métrica de regressor de erro quadrático médio, que é calculada durante o teste e a validação. Ao ajustar o modelo para tarefas de regressão, escolha essa métrica como a métrica objetiva.
| Nome da métrica | Description | Direção de otimização |
| --- | --- | --- |
| test:mean\$1squared\$1error | O erro quadrático médio | Minimizar |
| validation:mean\$1squared\$1error | O erro quadrático médio | Minimizar |
### Métricas de classificação calculadas pelo algoritmo Object2Vec
O algoritmo Object2Vec relata métricas de classificação de precisão e entropia cruzada, que são calculadas durante o teste e a validação. Ao ajustar o modelo para tarefas de classificação, escolha uma delas como o objetivo.
| Nome da métrica | Description | Direção de otimização |
| --- | --- | --- |
| test:accuracy | Precisão | Maximizar |
| test:cross\$1entropy | Entropia cruzada | Minimizar |
| validation:accuracy | Precisão | Maximizar |
| validation:cross\$1entropy | Entropia cruzada | Minimizar |
## Hiperparâmetros ajustáveis de Object2Vec
Você pode ajustar os seguintes hiperparâmetros para o algoritmo Object2Vec:
| Nome do hiperparâmetro | Tipo de hiperparâmetro | Intervalos e valores recomendados |
| --- | --- | --- |
| 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 |
# Formatos de dados para treinamento em Object2Vec
No treinamento com o algoritmo Object2Vec, certifique-se de que os dados de entrada em sua solicitação estejam no formato JSON Lines, onde cada linha representa um único ponto de dados.
## Entrada: formato de solicitação JSON Lines
Content-type: 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" e "in1" são as entradas para encoder0 e encoder1, respectivamente. O mesmo formato é válido para problemas de classificação e regressão. Para regressão, o campo `"label"` pode aceitar entradas com valor real.
# Formatos de dados para inferência em Object2Vec
A página a seguir descreve os formatos de solicitação de entrada e resposta de saída para obter inferência de pontuação do modelo Amazon SageMaker AI Object2Vec.
## Otimização de GPU: classificação ou regressão
Devido à falta de memória de GPU, a variável de ambiente `INFERENCE_PREFERRED_MODE` pode ser especificada para otimização se a classificação/regressão ou a rede de inferência [Saída: incorporações de codificador](object2vec-encoder-embeddings.md#object2vec-out-encoder-embeddings-data) for carregada na GPU. Se a maior parte da inferência for para classificação ou regressão, especifique `INFERENCE_PREFERRED_MODE=classification`. Veja a seguir um exemplo de Batch Transform do uso de 4 instâncias de p3.2xlarge que otimizam para inferência: 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)
```
## Entrada: formato da solicitação de classificação ou regressão
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]}
]
}
```
Content-type: 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]}
```
Para problemas de classificação, o comprimento do vetor de pontuações corresponde a `num_classes`. Para problemas de regressão, o comprimento é 1.
## Saída: Formato de resposta de Classificação ou Regressão
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]}
```
Nos formatos de classificação e regressão, as pontuações se aplicam a rótulos individuais.
# Incorporações de codificadores para Object2Vec
A página a seguir lista os formatos de solicitação de entrada e resposta de saída para obter inferência de incorporação de codificadores do modelo Amazon SageMaker AI Object2Vec.
## Otimização de GPU: incorporações de codificador
Uma incorporação é um mapeamento de objetos discretos, como palavras, para vetores de números reais.
Devido à falta de memória de GPU, a variável de ambiente `INFERENCE_PREFERRED_MODE` pode ser especificada para otimização se [Formatos de dados para inferência em Object2Vec](object2vec-inference-formats.md) ou a rede de inferência de incorporação de codificador for carregada na GPU. Se a maior parte da inferência for para incorporações de codificador, especifique `INFERENCE_PREFERRED_MODE=embedding`. Veja a seguir um exemplo de transformação em lotes usando 4 instâncias de p3.2xlarge que otimiza para inferência de incorporação de codificador:
```
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)
```
## Entrada: incorporações de codificador
Content-type: application/json; infer\$1max\$1seqlens=,
Em que e são inteiros no intervalo [1,5000] e definem os comprimentos máximos de sequência para o codificador para a frente e para trás.
```
{
"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=,
Em que e são inteiros no intervalo [1,5000] e definem os comprimentos máximos de sequência para o codificador para a frente e para trás.
```
{"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]}
```
Em ambos os formatos, você especifica apenas um tipo de entrada, ou `“in0”` ou `“in1.”`. O serviço de inferência invoca o codificador correspondente e gera as incorporações para cada uma das instâncias.
## Saída: incorporações de codificador
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]}
]
}
```
Content-type: 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]}
```
O comprimento de vetor das incorporações geradas pelo serviço de inferência é igual ao valor de um dos hiperparâmetros a seguir, que você especifica na ocasião do treinamento: `enc0_token_embedding_dim`, `enc1_token_embedding_dim` ou `enc_dim`.
# 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] |
# Classificação de texto - TensorFlow
[O algoritmo Amazon SageMaker AI Text Classification - é um TensorFlow algoritmo de aprendizado supervisionado que oferece suporte ao aprendizado por transferência com muitos modelos pré-treinados do TensorFlow Hub.](https://tfhub.dev/) Use transferir aprendizado para ajustar um dos modelos pré-treinados disponíveis em seu próprio conjunto de dados, mesmo que uma grande quantidade de dados de texto não esteja disponível. O algoritmo de classificação de texto usa uma string de texto como de entrada e saída como uma probabilidade para cada um dos rótulos de classe. Os conjuntos de dados de treinamento devem estar no formato CSV. Esta página inclui informações sobre recomendações de instâncias do Amazon EC2 e exemplos de notebooks para classificação de texto -. TensorFlow
**Topics**
+ [Como usar o TensorFlow algoritmo SageMaker AI Text Classification](text-classification-tensorflow-how-to-use.md)
+ [Interface de entrada e saída para o TensorFlow algoritmo de classificação de texto](text-classification-tensorflow-inputoutput.md)
+ [Recomendação de instância do Amazon EC2 para o algoritmo de classificação de texto TensorFlow](#text-classification-tensorflow-instances)
+ [Classificação de texto - TensorFlow exemplos de cadernos](#text-classification-tensorflow-sample-notebooks)
+ [Como TensorFlow funciona a classificação de texto](text-classification-tensorflow-HowItWorks.md)
+ [TensorFlow Modelos de hub](text-classification-tensorflow-Models.md)
+ [Classificação de texto - TensorFlow Hiperparâmetros](text-classification-tensorflow-Hyperparameter.md)
+ [Ajustar uma classificação de texto - TensorFlow modelo](text-classification-tensorflow-tuning.md)
# Como usar o TensorFlow algoritmo SageMaker AI Text Classification
Você pode usar a Classificação de Texto - TensorFlow como um algoritmo integrado da Amazon SageMaker AI. A seção a seguir descreve como usar a Classificação de Texto TensorFlow com o SageMaker SDK AI Python. Para obter informações sobre como usar a classificação de texto na interface TensorFlow do usuário do Amazon SageMaker Studio Classic, consulte[SageMaker JumpStart modelos pré-treinados](studio-jumpstart.md).
O TensorFlow algoritmo de Classificação de Texto suporta o aprendizado por transferência usando qualquer um dos TensorFlow modelos pré-treinados compatíveis. Para obter uma lista de todos os modelos pré-treinados disponíveis, consulte [TensorFlow Modelos de hub](text-classification-tensorflow-Models.md). Cada modelo pré-treinado tem um `model_id` exclusivo. O seguinte exemplo usa BERT Base Uncased (`model_id`:`tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2`) para ajustar um conjunto de dados personalizado. Os modelos pré-treinados são todos pré-baixados do TensorFlow Hub e armazenados em buckets do Amazon S3 para que os trabalhos de treinamento possam ser executados isoladamente na rede. Use esses artefatos de treinamento de modelos pré-gerados para criar um estimador de SageMaker IA.
Primeiro, recupere o URI da imagem do Docker, o URI do script de treinamento e o URI do modelo pré-treinado. Em seguida, altere os hiperparâmetros conforme desejar. Você pode ver um dicionário Python de todos os hiperparâmetros disponíveis e seus valores padrão com `hyperparameters.retrieve_default`. Para obter mais informações, consulte [Classificação de texto - TensorFlow Hiperparâmetros](text-classification-tensorflow-Hyperparameter.md). Use esses valores para criar um estimador de SageMaker IA.
**nota**
Os valores padrão dos hiperparâmetros são diferentes para modelos diferentes. Por exemplo, para modelos maiores, o tamanho padrão do lote é menor.
Este exemplo usa o conjunto de dados [https://www.tensorflow.org/datasets/catalog/glue#gluesst2](https://www.tensorflow.org/datasets/catalog/glue#gluesst2), que contém resenhas de filmes positivas e negativas. Nós pré-baixamos o conjunto de dados e o disponibilizamos com o Amazon S3. Para ajustar seu modelo, chame `.fit` usando a localização do Amazon S3 do seu conjunto de dados de treinamento. Qualquer bucket do S3 usado em um notebook deve estar na mesma AWS região da instância do notebook que o acessa.
```
from sagemaker import image_uris, model_uris, script_uris, hyperparameters
from sagemaker.estimator import Estimator
model_id, model_version = "tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2", "*"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the Docker image
train_image_uri = image_uris.retrieve(model_id=model_id,model_version=model_version,image_scope="training",instance_type=training_instance_type,region=None,framework=None)
# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="training")
# Retrieve the pretrained model tarball for transfer learning
train_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="training")
# Retrieve the default hyperparameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=model_id, model_version=model_version)
# [Optional] Override default hyperparameters with custom values
hyperparameters["epochs"] = "5"
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/SST2/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tc-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
# Create an Estimator instance
tf_tc_estimator = Estimator(
role=aws_role,
image_uri=train_image_uri,
source_dir=train_source_uri,
model_uri=train_model_uri,
entry_point="transfer_learning.py",
instance_count=1,
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location,
)
# Launch a training job
tf_tc_estimator.fit({"training": training_dataset_s3_path}, logs=True)
```
Para obter mais informações sobre como usar o TensorFlow algoritmo de Classificação de SageMaker Texto para transferir o aprendizado em um conjunto de dados personalizado, consulte o caderno [Introdução à JumpStart Classificação de Texto](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).
# Interface de entrada e saída para o TensorFlow algoritmo de classificação de texto
Cada um dos modelos pré-treinados listados nos TensorFlow Hub Models pode ser ajustado a qualquer conjunto de dados composto por frases de texto com qualquer número de classes. O modelo pré-treinado anexa uma camada de classificação ao modelo de incorporação de texto e inicializa os parâmetros da camada com valores aleatórios. A dimensão de saída da camada de classificação é determinada com base no número de classes detectadas nos dados de entrada.
Lembre-se de como formatar seus dados de treinamento para entrada no TensorFlow modelo de Classificação de Texto.
+ **Formato de entrada de dados de treinamento:** um diretório contendo um arquivo `data.csv`. Cada linha da primeira coluna deve ter rótulos de classe inteiros entre 0 e o número de classes. Cada linha da segunda coluna deve ter os dados de texto correspondentes.
Veja a seguir um exemplo de um arquivo de entrada CSV. Observe que o arquivo não deve ter nenhum cabeçalho. O arquivo deve ser hospedado em um bucket do Amazon S3 com um caminho semelhante ao seguinte: `s3://bucket_name/input_directory/`. Observe que o rastreamento `/` é obrigatório.
```
| | |
|---|---|
|0 |hide new secretions from the parental units|
|0 |contains no wit , only labored gags|
|1 |that loves its characters and communicates something rather beautiful about human nature|
|...|...|
```
## Treinamento incremental
Você pode semear o treinamento de um novo modelo com artefatos de um modelo que você treinou anteriormente com SageMaker IA. Um treinamento incremental economiza tempo de treinamento quando você deseja treinar um novo modelo com dados iguais ou semelhantes.
**nota**
Você só pode semear um modelo de Classificação de Texto de SageMaker IA com outro TensorFlow modelo de Classificação de Texto treinado em SageMaker IA. TensorFlow
Você pode usar qualquer conjunto de dados para treinamento incremental, desde que o conjunto de classes permaneça o mesmo. A etapa de treinamento incremental é semelhante à etapa de ajuste, mas em vez de começar com um modelo pré-treinado, você começa com um modelo já ajustado.
Para obter mais informações sobre como usar o treinamento incremental com o TensorFlow algoritmo SageMaker AI Text Classification, consulte o exemplo de caderno [Introdução à JumpStart Classificação de Texto](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).
## Inferência com a classificação de texto - algoritmo TensorFlow
Você pode hospedar o modelo ajustado que resulta do seu treinamento de Classificação de TensorFlow Texto para inferência. Qualquer formato de texto bruto para inferência deve ser do tipo de `application/x-text` conteúdo.
A execução da inferência resulta em valores de probabilidade, rótulos de classe para todas as classes e o rótulo previsto correspondente ao índice da classe com a maior probabilidade codificada no formato JSON. O TensorFlow modelo Text Classification - processa uma única string por solicitação e gera somente uma linha. Veja a seguir um exemplo de resposta no formato JSON.
```
accept: application/json;verbose
{"probabilities": [prob_0, prob_1, prob_2, ...],
"labels": [label_0, label_1, label_2, ...],
"predicted_label": predicted_label}
```
Se `accept` estiver definido como `application/json`, o modelo só gera probabilidades.
## Recomendação de instância do Amazon EC2 para o algoritmo de classificação de texto TensorFlow
O TensorFlow algoritmo de classificação de texto é compatível com todas as instâncias de CPU e GPU para treinamento, incluindo:
+ `ml.p2.xlarge`
+ `ml.p2.16xlarge`
+ `ml.p3.2xlarge`
+ `ml.p3.16xlarge`
+ `ml.g4dn.xlarge`
+ `ml.g4dn.16.xlarge`
+ `ml.g5.xlarge`
+ `ml.g5.48xlarge`
Recomendamos o uso de instâncias de GPU com mais memória para treinamento com grandes tamanhos de lote. Tanto as instâncias de CPU (como M5) quanto as de GPU (P2, P3, G4dn ou G5) podem ser usadas para inferência. Para obter uma lista abrangente de instâncias de SageMaker treinamento e inferência em todas AWS as regiões, consulte [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
## Classificação de texto - TensorFlow exemplos de cadernos
Para obter mais informações sobre como usar o TensorFlow algoritmo SageMaker AI Text Classification para transferir o aprendizado em um conjunto de dados personalizado, consulte o caderno [Introdução à JumpStart Classificação de Texto](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).
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. Para abrir um caderno, escolha a guia **Uso** e depois escolha **Criar cópia**.
# Como TensorFlow funciona a classificação de texto
O TensorFlow algoritmo Classificação de Texto - considera o texto conforme o classifica em um dos rótulos da classe de saída. Redes de aprendizado profundo, como o [BERT](https://arxiv.org/pdf/1810.04805.pdf), são altamente precisas para classificação de textos. Também existem redes de aprendizado profundo treinadas em grandes conjuntos de dados de texto, como, por exemplo TextNet, que tem mais de 11 milhões de textos com cerca de 11.000 categorias. Depois que uma rede é treinada com TextNet dados, você pode então ajustar a rede em um conjunto de dados com um foco específico para realizar tarefas de classificação de texto mais específicas. O TensorFlow algoritmo Amazon SageMaker AI Text Classification suporta o aprendizado por transferência em muitos modelos pré-treinados que estão disponíveis no TensorFlow Hub.
De acordo com o número de rótulos de classe em seus dados de treinamento, uma camada de classificação de texto é anexada ao TensorFlow modelo pré-treinado de sua escolha. A camada de classificação consiste em uma camada suspensa, uma camada densa e uma camada totalmente conectada com regularização de duas normas e é inicializada com pesos aleatórios. Você pode alterar os valores dos hiperparâmetros para a taxa de eliminação da camada de eliminação e o fator de regularização L2 para a camada densa.
Você pode ajustar toda a rede (incluindo o modelo pré-treinado) ou somente a camada de classificação superior nos novos dados de treinamento. Com esse método de transferência de aprendizado, é possível treinar com conjuntos de dados menores.
# TensorFlow Modelos de hub
Os seguintes modelos pré-treinados estão disponíveis para uso no aprendizado por transferência com o TensorFlow algoritmo de Classificação de Texto.
Os modelos a seguir variam significativamente em tamanho, número de parâmetros do modelo, tempo de treinamento e latência de inferência para qualquer conjunto de dados. O melhor modelo para seu caso de uso depende da complexidade do seu conjunto de dados de ajuste fino e de quaisquer requisitos que você tenha sobre tempo de treinamento, latência de inferência ou precisão do modelo.
| Nome do modelo | `model_id` | Fonte |
| --- | --- | --- |
| Base BERT uncased | `tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3) |
| Base BERT cased | `tensorflow-tc-bert-en-cased-L-12-H-768-A-12-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3) |
| Estojo multilíngue Base BERT | `tensorflow-tc-bert-multi-cased-L-12-H-768-A-12-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3) |
| BERT pequeno L-2\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-128-A-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1) |
| BERT pequeno L-2\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-256-A-4` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1) |
| BERT pequeno L-2\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-512-A-8` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1) |
| BERT pequeno L-2\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-768-A-12` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1) |
| BERT pequeno L-4\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-128-A-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1) |
| BERT pequeno L-4\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-256-A-4` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1) |
| BERT pequeno L-4\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-512-A-8` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1) |
| BERT pequeno L-4\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-768-A-12` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1) |
| BERT pequeno L-6\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-128-A-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1) |
| BERT pequeno L-6\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-256-A-4` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1) |
| BERT pequeno L-6\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-512-A-8` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1) |
| BERT pequeno L-6\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-768-A-12` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1) |
| BERT pequeno L-8\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-128-A-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1) |
| BERT pequeno L-8\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-256-A-4` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1) |
| BERT pequeno L-8\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-512-A-8` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1) |
| BERT pequeno L-8\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-768-A-12` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1) |
| BERT pequeno L-10\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-128-A-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1) |
| BERT pequeno L-10\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-256-A-4` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1) |
| BERT pequeno L-10\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-512-A-8` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1) |
| BERT pequeno L-10\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-768-A-12` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1) |
| BERT pequeno L-12\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-128-A-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1) |
| BERT pequeno L-12\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-256-A-4` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1) |
| BERT pequeno L-12\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-512-A-8` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1) |
| BERT pequeno L-12\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-768-A-12` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1) |
| BERT grande uncased | `tensorflow-tc-bert-en-uncased-L-24-H-1024-A-16-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/3) |
| BERT grande cased | `tensorflow-tc-bert-en-cased-L-24-H-1024-A-16-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/bert_en_cased_L-24_H-1024_A-16/3) |
| Máscara de palavras inteiras BERT grande uncased | `tensorflow-tc-bert-en-wwm-uncased-L-24-H-1024-A-16-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/bert_en_wwm_uncased_L-24_H-1024_A-16/3) |
| Máscara de palavras inteiras BERT grande cased | `tensorflow-tc-bert-en-wwm-cased-L-24-H-1024-A-16-2` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/bert_en_wwm_cased_L-24_H-1024_A-16/3) |
| Base ALBERT | `tensorflow-tc-albert-en-base` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/albert_en_base/2) |
| ELECTRA Small\$1\$1 | `tensorflow-tc-electra-small-1` | [TensorFlow Link do hub](https://tfhub.dev/google/electra_small/2) |
| Base ELECTRA | `tensorflow-tc-electra-base-1` | [TensorFlow Link do hub](https://tfhub.dev/google/electra_base/2) |
| BERT Base Wikipedia e BooksCorpus | `tensorflow-tc-experts-bert-wiki-books-1` | [TensorFlow Link do hub](https://tfhub.dev/google/experts/bert/wiki_books/2) |
| BERT Base MEDLINE/ PubMed | `tensorflow-tc-experts-bert-pubmed-1` | [TensorFlow Link do hub](https://tfhub.dev/google/experts/bert/pubmed/2) |
| Base Talking Heads | `tensorflow-tc-talking-heads-base` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1) |
| Base Talking Heads | `tensorflow-tc-talking-heads-large` | [TensorFlow Link do hub](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_large/1) |
# Classificação de texto - TensorFlow Hiperparâmetros
Hiperparâmetros são parâmetros definidos antes de um modelo de machine learning começar a aprender. Os hiperparâmetros a seguir são compatíveis com o TensorFlow algoritmo de detecção de objetos incorporado ao Amazon SageMaker AI. Para obter informações sobre ajuste de hiperparâmetros, consulte [Ajustar uma classificação de texto - TensorFlow modelo](text-classification-tensorflow-tuning.md).
| Nome do parâmetro | Description |
| --- | --- |
| batch\$1size | O tamanho do lote para treinamento. Para treinamento em instâncias com várias GPUs, esse tamanho de lote é usado em todo GPUs o. Valores válidos: inteiro positivo. Valor padrão: `32`. |
| beta\$11 | O beta1 para os otimizadores `"adam"` e `"adamw"`. Representa a taxa de degradação exponencial para as estimativas de primeiro momento. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.9`. |
| beta\$12 | O beta2 para os otimizadores `"adam"` e `"adamw"`. Representa a taxa de degradação exponencial para as estimativas de segundo momento. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.999`. |
| dropout\$1rate | A taxa de eliminação da camada de eliminação na camada de classificação superior. Usado somente quando `reinitialize_top_layer` for definido como `"True"`. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.2` |
| early\$1stopping | Defina para `"True"` para usar a lógica de interrupção antecipada durante o treinamento. Se `"False"`, a interrupção antecipada não é usada. Valores válidos: string, ou: (`"True"` ou `"False"`). Valor padrão: `"False"`. |
| early\$1stopping\$1min\$1delta | A alteração mínima necessária para se qualificar como uma melhoria. Uma mudança absoluta menor que o valor de early\$1stopping\$1min\$1delta não se qualifica como melhoria. Usado somente quando early\$1stopping for definido como "True".Valores válidos: flutuante, intervalo: [`0.0`, `1.0`].Valor padrão: `0.0`. |
| early\$1stopping\$1patience | O número de épocas para continuar treinando sem melhorias. Usado somente quando `early_stopping` for definido como `"True"`. Valores válidos: inteiro positivo. Valor padrão: `5`. |
| epochs | O número de epochs de treinamento. Valores válidos: inteiro positivo. Valor padrão: `10`. |
| epsilon | O épsilon para os otimizadores `"adam"`, `"rmsprop"`, `"adadelta"` e `"adagrad"`. Geralmente é definido como um valor baixo, para evitar a divisão por 0. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `1e-7`. |
| initial\$1accumulator\$1value | O valor inicial para os acumuladores, ou os valores de momentum por parâmetro, para o otimizador `"adagrad"`. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.0001`. |
| learning\$1rate | A taxa de aprendizado do otimizador. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`].Valor padrão: `0.001`. |
| momentum | A dinâmica dos otimizadores `"sgd"` e `"nesterov"`. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.9`. |
| optimizer | O tipo de otimizador. Para obter mais informações, consulte [Otimizadores](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers) na TensorFlow documentação. Valores válidos: string, qualquer um dos seguintes: (`"adamw"`, `"adam"`, `"sgd"`, `"nesterov"`, `"rmsprop"`, ` "adagrad"` ou `"adadelta"`). Valor padrão: `"adam"`. |
| regularizers\$1l2 | O fator de regularização L2 para a camada densa na camada de classificação. Usado somente quando `reinitialize_top_layer` for definido como `"True"`. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.0001`. |
| reinitialize\$1top\$1layer | Se definido como `"Auto"`, os parâmetros da camada de classificação superior são reinicializados durante o ajuste fino. Para treinamento incremental, os parâmetros da camada de classificação superior não são reinicializados, a menos que sejam definidos como `"True"`. Valores válidos: string, qualquer um dos seguintes: (`"Auto"`, `"True"` ou `"False"`). Valor padrão: `"Auto"`. |
| rho | O fator de desconto para o gradiente dos otimizadores `"adadelta"` e `"rmsprop"`. Ignorado por outros otimizadores. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.95`. |
| train\$1only\$1on\$1top\$1layer | Se `"True"`, somente os parâmetros da camada de classificação superior forem ajustados. Se `"False"`, todos os parâmetros do modelo são ajustados. Valores válidos: string, ou: (`"True"` ou `"False"`). Valor padrão: `"False"`. |
| validation\$1split\$1ratio | A fração de dados de treinamento a ser dividida aleatoriamente para criar dados de validação. Usado somente se os dados de validação não forem fornecidos pelo canal `validation`. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.2`. |
| warmup\$1steps\$1fraction | A fração do número total de etapas de atualização do gradiente, em que a taxa de aprendizado aumenta de 0 para a taxa de aprendizado inicial como um aquecimento. Usado somente com o otimizador `adamw`. Valores válidos: flutuante, intervalo: [`0.0`, `1.0`]. Valor padrão: `0.1`. |
# Ajustar uma classificação de texto - TensorFlow 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 de Classificação de Texto TensorFlow
Consulte a tabela a seguir para descobrir quais métricas são calculadas pelo TensorFlow algoritmo de Classificação de Texto.
| Nome da métrica | Description | Direção de otimização | Padrão Regex |
| --- | --- | --- | --- |
| validation:accuracy | A proporção do número de predições corretas para o número total de predições feitas. | Maximizar | `val_accuracy=([0-9\\.]+)` |
## Classificação de texto ajustável - hiperparâmetros TensorFlow
Ajuste um modelo de classificação de texto com os seguintes hiperparâmetros: Os hiperparâmetros que têm o maior impacto nas métricas objetivas de classificação de texto são: `batch_size`, `learning_rate` e `optimizer`. Os hiperparâmetros ajustáveis relacionados ao otimizador como `momentum`, `regularizers_l2`, `beta_1`, `beta_2` e `eps` com base no `optimizer` selecionado. Por exemplo, use `beta_1` e `beta_2` somente quando `adamw` ou `adam` for o `optimizer`.
Para obter mais informações sobre quais hiperparâmetros são usados para cada `optimizer`, consulte [Classificação de texto - TensorFlow Hiperparâmetros](text-classification-tensorflow-Hyperparameter.md).
| Nome do parâmetro | Tipo de parâmetro | Intervalos recomendados |
| --- | --- | --- |
| batch\$1size | IntegerParameterRanges | MinValue: 4, MaxValue 128 |
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6, 0,99 MaxValue |
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6, 0,99 MaxValue |
| eps | ContinuousParameterRanges | MinValue: 1e-8, MaxValue: 1,0 |
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6, 0,5 MaxValue |
| momentum | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,99 |
| optimizer | CategoricalParameterRanges | ['adamw', 'adam', 'sgd', 'rmsprop', 'nesterov', 'adagrad', 'adadelta'] |
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,99 |
| train\$1only\$1on\$1top\$1layer | CategoricalParameterRanges | ['True', 'False'] |