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á.
# 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`.