Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Algoritmo Object2Vec
El algoritmo Object2Vec de Amazon SageMaker AI es un algoritmo de incrustación neuronal de uso general que es altamente personalizable. Puede aprender integraciones densas de baja dimensionalidad de objetos de alta dimensionalidad. Las integraciones se aprenden de tal forma que conservan la semántica de la relación entre pares de objetos en el espacio original, en el espacio de integración. Puede utilizar las integraciones aprendidas, por ejemplo, para calcular de forma eficaz los vecinos más próximos de objetos y para visualizar clústeres naturales de objetos relacionados en espacio de baja dimensionalidad. También puede utilizar las integraciones como características de los objetos correspondientes en las tareas supervisadas posteriores, como, por ejemplo, clasificación o regresión.
Object2Vec generaliza la conocida técnica de incrustación de palabras de Word2Vec, que está optimizada en la IA. SageMaker [BlazingText algoritmo](blazingtext.md) Para ver una entrada de blog en la que se explica cómo aplicar Object2Vec a algunos casos de uso prácticos, consulte Introducción [a Amazon SageMaker ](https://aws.amazon.com/blogs/machine-learning/introduction-to-amazon-sagemaker-object2vec/) AI Object2Vec.
**Topics**
+ [Interfaz de E/S para el algoritmo Object2Vec](#object2vec-inputoutput)
+ [Recomendación de la instancia EC2 para el algoritmo Object2Vec](#object2vec--instances)
+ [Cuadernos de ejemplo de Object2Vec](#object2vec-sample-notebooks)
+ [Cómo funciona Object2Vec](object2vec-howitworks.md)
+ [Object2Vec Hyperparameters](object2vec-hyperparameters.md)
+ [Ajuste de un modelo Object2Vec](object2vec-tuning.md)
+ [Formatos de datos para la capacitación de Object2Vec](object2vec-training-formats.md)
+ [Formato de datos para inferencia de Object2Vec](object2vec-inference-formats.md)
+ [Integraciones de codificador para Object2Vec](object2vec-encoder-embeddings.md)
## Interfaz de E/S para el algoritmo Object2Vec
Puede utilizar Object2Vec en varios tipos de datos de entrada, incluidos los ejemplos siguientes:
| Tipo de datos de entrada | Ejemplo |
| --- | --- |
| Pares frase-frase | “Un partido de fútbol con varios hombres jugando”. y “Algunos hombres practicando deporte”. |
| Pares de etiquetas-secuencia | Las etiquetas de género de la película “Titanic”, como “Romance” y “Drama”, y una breve descripción: "La película Titanic de James Cameron es un romance épico con mucha acción donde se narra el primer y funesto viaje inaugural del R.M.S. Titanic”. Fue el navío más lujoso de su época, un barco de ensueño, que acabó llevando a más de 1500 personas a su muerte en las aguas heladas del Atlántico Norte, en la madrugada del 15 de abril de 1912". |
| Pares de cliente-cliente | El ID de cliente Jane y el ID de cliente de Jackie. |
| Pares de producto-producto | El ID de producto de fútbol americano e ID de producto de baloncesto. |
| Pares de revisión de elemento-elemento de usuario | El ID de un usuario y los productos que ha comprado como, por ejemplo, manzanas, peras y naranjas. |
Para transformar los datos de entrada en los formatos admitidos, debe preprocesarlos. Actualmente, Object2Vec admite nativamente dos tipos de entradas:
+ Un token discreto, que se representa como una lista de un único `integer-id`. Por ejemplo, `[10]`.
+ Una secuencia de tokens discretos, que se representa como una lista de `integer-ids`. Por ejemplo, `[0,12,10,13]`.
El objeto en cada par puede ser asimétrico. Por ejemplo, los pares pueden ser (token, secuencia) o (token, token) o (secuencia, secuencia). Para las entradas de token, el algoritmo admite integraciones simples como codificadores compatibles. Para secuencias de vectores de token, el algoritmo admite lo siguiente como codificadores:
+ Integraciones medias-agrupadas
+ Redes neuronales convolucionales jerárquicas (), CNNs
+ Memoria bidireccional a largo plazo (Bi) multicapa LSTMs
La etiqueta de entrada de cada par puede ser una de las siguientes:
+ Una etiqueta categórica que expresa la relación entre los objetos del par.
+ Una puntuación que expresa el grado de la similitud entre los dos objetos.
Para etiquetas categóricas usadas en clasificación, el algoritmo soporta la función de pérdida entropía cruzada. Para etiquetas basadas en calificaciones/puntuación usadas en regresión, el algoritmo admite la función de pérdida de error cuadrático medio (MSE). Especifique estas funciones de pérdida con el hiperparámetro `output_layer` al crear el trabajo de capacitación de modelo.
## Recomendación de la instancia EC2 para el algoritmo Object2Vec
El tipo de instancia Amazon Elastic Compute Cloud (Amazon EC2) que utilice dependerá de si está entrenando o ejecutando inferencias.
Cuando capacite un modelo mediante el algoritmo Object2Vec en una CPU, comience por una instancia ml.m5.2xlarge. Para capacitaciones en una GPU, comience por una instancia ml.p2.xlarge. Si el entrenamiento dura demasiado en esta instancia, puede usar una instancia más grande. En la actualidad, el algoritmo Object2Vec solo puede entrenar en una máquina. Sin embargo, sí ofrece soporte para múltiples. GPUs El algoritmo Object2Vec admite las familias de instancias de GPU P2, P3, G4dn y G5 para el entrenamiento y la inferencia.
Para la inferencia con un modelo Object2Vec que tiene una red neuronal profunda, recomendamos que se use la instancia de GPU ml.p3.2xlarge. Debido a la escasez de memoria de GPU, la variable de entorno `INFERENCE_PREFERRED_MODE` se puede especificar para su optimización en cuanto a si la red de inferencia [Optimización de GPU: clasificación o regresión](object2vec-inference-formats.md#object2vec-inference-gpu-optimize-classification) o [Optimización de GPU: integraciones de codificador](object2vec-encoder-embeddings.md#object2vec-inference-gpu-optimize-encoder-embeddings) se carga en GPU.
## Cuadernos de ejemplo de Object2Vec
+ [Using Object2Vec to Encode Sentences into Fixed Length Embeddings](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/object2vec_sentence_similarity/object2vec_sentence_similarity.html)
# Cómo funciona Object2Vec
Al utilizar el algoritmo Object2Vec de Amazon SageMaker AI, se sigue el flujo de trabajo estándar: se procesan los datos, se entrena el modelo y se producen inferencias.
**Topics**
+ [Paso 1: Procesar datos](#object2vec-step-1-data-preprocessing)
+ [Paso 2: Capacitar un modelo](#object2vec-step-2-training-model)
+ [Paso 3: Producir inferencias](#object2vec-step-3-inference)
## Paso 1: Procesar datos
Durante el procesamiento previo, convierta los datos al formato de archivo de texto [Líneas de JSON](http://jsonlines.org/) especificado en [Formatos de datos para la capacitación de Object2Vec](object2vec-training-formats.md). Para obtener la máxima precisión durante la capacitación, mezcle de forma aleatoria los datos antes de introducirlos en el modelo. El modo en que genera las permutaciones aleatorias depende del lenguaje. Para Python, podría utilizar `np.random.shuffle`; para Unix, `shuf`.
## Paso 2: Capacitar un modelo
El algoritmo SageMaker AI Object2Vec tiene los siguientes componentes principales:
+ **Dos canales de entrada**: los canales de entrada toman como entradas un par de objetos del mismo tipo o de tipos diferentes y los pasan a codificadores independientes y personalizables.
+ **Dos codificadores**: los codificadores enc0 y enc1 convierten cada uno de los objetos en un vector de integración de longitud fija. Luego las integraciones codificadas de los objetos del par se transfieren a un comparador.
+ **Un comparador**: el comparador compara las incrustaciones de diferentes maneras y genera puntuaciones que indican la fuerza de la relación entre los objetos emparejados. En la puntuación obtenida para un par de frases. Por ejemplo, 1 indica una relación estrecha entre un par de frases y 0 representa una relación menos fuerte.
Durante la capacitación, el algoritmo acepta pares de objetos y sus etiquetas de relación o puntuaciones como entradas. Los objetos de cada par pueden ser de diferentes tipos, tal y como se ha descrito anteriormente. Si las entradas a ambos codificadores están compuestas por las mismas unidades de nivel de token, puede utilizar una capa de integración de token compartida estableciendo el hiperparámetro `tied_token_embedding_weight` en `True` al crear el trabajo de capacitación. Esto es posible, por ejemplo, al comparar frases que tienen ambas unidades de nivel de token de palabra. Para generar muestras negativas a una velocidad especificada, establezca el hiperparámetro `negative_sampling_rate` en la proporción deseada de muestras negativas a positivas. Este hiperparámetro acelera el aprendizaje de cómo distinguir entre las muestras positivas observada en los datos de capacitación y las muestras negativas que no es probable que se observen.
Se pasan pares de objetos a través de codificadores personalizables e independientes que son compatibles con los tipos de entrada de objetos correspondientes. Los codificadores convierten cada uno de los objetos de un par en un vector de integración de longitud fija de igual longitud. El par de vectores se transfieren a un operador comparador, que combina los vectores en un solo vector con el valor especificado en el hiperparámetro `comparator_list`. Luego, el vector montado pasa por una capa perceptron multicapa (MLP), que produce una salida que la función de pérdida compara con las etiquetas que se han proporcionado. Esta comparación evalúa la fuerza de la relación entre los objetos del par, según prevé el modelo. En la siguiente figura se muestra este flujo de trabajo.
![\[Arquitectura del algoritmo Object2Vec desde entradas de datos hasta puntuaciones\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/object2vec-training-image.png)
## Paso 3: Producir inferencias
Una vez que el modelo está capacitado, puede utilizar el codificador capacitado para preprocesar los objetos de entrada o para realizar dos tipos de inferencia:
+ Para convertir objetos de entrada de singleton en integraciones de longitud fija mediante el codificador correspondiente
+ Para predecir la etiqueta de relación o puntuación entre un par de objetos de entrada
El servidor de inferencia descubre automáticamente cuál de los tipos es solicitado en función de los datos de entrada. Para obtener las integraciones como salida, proporcione una única entrada. Para predecir la etiqueta de relación o puntuación, proporcione ambas entradas del par.
# Object2Vec Hyperparameters
En la solicitud `CreateTrainingJob`, especifique el algoritmo de capacitación. También puede especificar hiperparámetros específicos del algoritmo como mapas. string-to-string En la siguiente tabla se muestran los hiperparámetros para el algoritmo de capacitación Object2Vec.
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| enc0\$1max\$1seq\$1len | La longitud de secuencia máxima para el codificador enc0. **Obligatorio** Valores válidos: 1 ≤ entero ≤ 5000 |
| enc0\$1vocab\$1size | El tamaño de vocabulario de tokens enc0. **Obligatorio** Valores válidos: 2 ≤ entero ≤ 3 000 000 |
| bucket\$1width | La diferencia permitida entre la longitud de la secuencia de datos cuando el almacenamiento en buckets está habilitado. Para habilitar el almacenamiento en buckets, especifique un valor distinto de cero para este parámetro. **Opcional** Valores válidos: 0 ≤ entero ≤ 100 Valor predeterminado: 0 (no bucketing) |
| comparator\$1list | Una lista que se utiliza para personalizar la forma en que se comparan dos integraciones. La capa de operador comparador de Object2Vec toma las codificaciones de ambos codificadores como entradas y genera un único vector. Este vector es una concatenación de subvectores. Los valores de cadena transferidos a la `comparator_list` y el orden en que se pasan determinan cómo se montan estos subvectores. Por ejemplo, si `comparator_list="hadamard, concat"`, el operador comparador crea el vector concatenando el producto Hadamard de dos codificaciones y la concatenación de dos codificaciones. Si, por el contrario, `comparator_list="hadamard"`, el comparador vector construirá el vector como el producto hadamard de solo dos codificaciones. **Opcional** Valores válidos: cadena que contiene cualquier combinación de los nombres de los tres operadores binarios: `hadamard`, `concat` o `abs_diff`. El algoritmo Object2Vec necesita actualmente que las dos codificaciones de vectores tengan la misma dimensión. Estos operadores producir los subvectores tal y como se indica a continuación: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor predeterminado: `"hadamard, concat, abs_diff"` |
| dropout | La probabilidad de abandono para capas de red. *Dropout* es una forma de regularización utilizada en redes neuronales que reduce el sobreajuste recortando las neuronas codependientes. **Opcional** Valores válidos: 0,0 ≤ flotante ≤ 1,0 Valor predeterminado: 0,0 |
| early\$1stopping\$1patience | El número de fechas de inicio consecutivas sin mejora permitida antes de que se aplique una detención temprana. La mejora se define con el hiperparámetro `early_stopping_tolerance`. **Opcional** Valores válidos: 1 ≤ entero ≤ 5 Valor predeterminado: 3 |
| early\$1stopping\$1tolerance | La reducción de la función de pérdida que un algoritmo debe conseguir entre fechas de inicio consecutivas para evitar una detención precoz después de que el número de fechas de inicio consecutivas especificado en el hiperparámetro `early_stopping_patience` concluya. **Opcional** Valores válidos: 0,000001 ≤ flotante ≤ 0,1 Valor predeterminado: 0,01 |
| enc\$1dim | La dimensión de la salida de la capa de integración. **Opcional** Valores válidos: 4 ≤ entero ≤ 10 000 Valor predeterminado: 4096 |
| enc0\$1network | El modelo de red para el codificador enc0. **Opcional** Valores válidos: `hcnn`, `bilstm` o `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor predeterminado: `hcnn` |
| enc0\$1cnn\$1filter\$1width | La anchura del filtro del codificador enc0 de la red neuronal convolucional (CNN). **Condicional** Valores válidos: 1 ≤ entero ≤ 9 Valor predeterminado: 3 |
| enc0\$1freeze\$1pretrained\$1embedding | Congelar o no ponderaciones de integraciones precapacitadas enc0. **Condicional** Valores válidos: `True` o `False` Valor predeterminado: `True` |
| enc0\$1layers | El número de capas ocultas del codificador enc0. **Condicional** Valores válidos: `auto` o 1 ≤ entero ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor predeterminado: `auto` |
| enc0\$1pretrained\$1embedding\$1file | El nombre del archivo de integración de token enc0 precapacitado en el canal de datos auxiliares. **Condicional** Valores válidos: cadenas con caracteres alfanuméricos, guion bajo o punto. [A-Za-z0-9\$1.\$1\$1] Valor predeterminado: "" (cadena vacía) |
| enc0\$1token\$1embedding\$1dim | La dimensión de la salida de la capa de integración de token enc0. **Condicional** Valores válidos: 2 ≤ entero ≤ 1000 Valor predeterminado: 300 |
| enc0\$1vocab\$1file | El archivo de vocabulario para mapear vectores de incrustación de tokens enc0 previamente entrenados a vocabulario numérico. IDs **Condicional** Valores válidos: cadenas con caracteres alfanuméricos, guion bajo o punto. [A-Za-z0-9\$1.\$1\$1] Valor predeterminado: "" (cadena vacía) |
| enc1\$1network | El modelo de red para el codificador enc1. Si desea que el codificador enc1 use el mismo modelo de red que enc0, incluidos los valores de hiperparámetros, establezca el valor en `enc0`. Incluso cuando las redes de codificadores enc1 y enc0 tienen arquitecturas simétricas, no puede compartir valores de parámetros para estas redes. **Opcional** Valores válidos: `enc0`, `hcnn`, `bilstm` o `pooled_embedding` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor predeterminado: `enc0` |
| enc1\$1cnn\$1filter\$1width | La anchura de filtro del codificador enc1 CNN. **Condicional** Valores válidos: 1 ≤ entero ≤ 9 Valor predeterminado: 3 |
| enc1\$1freeze\$1pretrained\$1embedding | Congelar o no ponderaciones de integraciones precapacitadas enc1. **Condicional** Valores válidos: `True` o `False` Valor predeterminado: `True` |
| enc1\$1layers | El número de capas del codificador enc1. **Condicional** Valores válidos: `auto` o 1 ≤ entero ≤ 4 [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor predeterminado: `auto` |
| enc1\$1max\$1seq\$1len | La longitud de secuencia máxima para el codificador enc1. **Condicional** Valores válidos: 1 ≤ entero ≤ 5000 |
| enc1\$1pretrained\$1embedding\$1file | El nombre de archivo de integración del token precapacitado enc1 en el canal de datos auxiliares. **Condicional** Valores válidos: cadenas con caracteres alfanuméricos, guion bajo o punto. [A-Za-z0-9\$1.\$1\$1] Valor predeterminado: "" (cadena vacía) |
| enc1\$1token\$1embedding\$1dim | La dimensión de la salida de la capa de integración de token enc1. **Condicional** Valores válidos: 2 ≤ entero ≤ 1000 Valor predeterminado: 300 |
| enc1\$1vocab\$1file | El archivo de vocabulario para asignar incrustaciones de tokens enc1 previamente entrenadas al vocabulario. IDs **Condicional** Valores válidos: cadenas con caracteres alfanuméricos, guion bajo o punto. [A-Za-z0-9\$1.\$1\$1] Valor predeterminado: "" (cadena vacía) |
| enc1\$1vocab\$1size | El tamaño de vocabulario de tokens enc0. **Condicional** Valores válidos: 2 ≤ entero ≤ 3 000 000 |
| epochs | El número de fechas de inicio a ejecutar para capacitación. **Opcional** Valores válidos: 1 ≤ entero ≤ 100 Valor predeterminado: 30 |
| learning\$1rate | La tasa de aprendizaje para capacitación. **Opcional** Valores válidos: 1,0E-6 ≤ flotante ≤ 1,0 Valor predeterminado: 0.0004 |
| mini\$1batch\$1size | El tamaño de lote en que el conjunto de datos se divide para `optimizer` durante la capacitación. **Opcional** Valores válidos: 1 ≤ entero ≤ 10 000 Valor predeterminado: 32 |
| mlp\$1activation | El tipo de función de activación para la capa perceptron multicapa (MLP). **Opcional** Valores válidos: `tanh`, `relu` o `linear` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor predeterminado: `linear` |
| mlp\$1dim | La dimensión de la salida de capas MLP. **Opcional** Valores válidos: 2 ≤ entero ≤ 10 000 Valor predeterminado: 512 |
| mlp\$1layers | El número de capas MLP en la red. **Opcional** Valores válidos: 0 ≤ entero ≤ 10 Valor predeterminado: 2 |
| negative\$1sampling\$1rate | La proporción de muestras negativas, generadas para ayudar a capacitar el algoritmo, por muestras positivas que los usuarios proporcionan. Las muestras negativas representan datos que es poco probable que se produzcan en la realidad y se etiquetan negativamente para la capacitación. Facilitan la capacitación de un modelo para distinguir entre las muestras positivas observadas y las muestras negativas que no lo son. Para especificar la proporción de muestras negativas por muestras positivas utilizado para la capacitación, establezca el valor en un número entero positivo. Por ejemplo, si capacita el algoritmo con datos de entrada en los que todas las muestras son positivas y establece `negative_sampling_rate` en 2, el algoritmo Object2Vec genera internamente dos muestras negativas por cada muestra positiva. Si no desea generar ni utilizar muestras negativas durante la capacitación, establezca el valor en 0. **Opcional** Valores válidos: 0 ≤ entero Valor predeterminado: 0 (desconectado) |
| num\$1classes | El número de clases para capacitación de clasificación. Amazon SageMaker AI ignora este hiperparámetro en caso de problemas de regresión. **Opcional** Valores válidos: 2 ≤ entero ≤ 30 Valor predeterminado: 2 |
| optimizer | El tipo de optimizador. **Opcional** Valores válidos: `adadelta`, `adagrad`, `adam`, `sgd` o `rmsprop`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor predeterminado: `adam` |
| output\$1layer | El tipo de capa de salida en la que se especifica que la tarea es una regresión o clasificación. **Opcional** Valores válidos: `softmax` o `mean_squared_error` [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/object2vec-hyperparameters.html) Valor predeterminado: `softmax` |
| tied\$1token\$1embedding\$1weight | Si se utiliza o no una capa de integración compartida para ambos codificadores. Si las entradas de ambos codificadores utilizan las mismas unidades de nivel de token, utilice una capa de integración de token compartido. Por ejemplo, en el caso de una colección de documentos, si un codificador codifica frases y otro codifica documentos completos, puede utilizar una capa de integración de token compartida. Esto se debe a que tanto las frases como los documentos se componen de tokens de palabras del mismo vocabulario. **Opcional** Valores válidos: `True` o `False` Valor predeterminado: `False` |
| token\$1embedding\$1storage\$1type | El modo de actualización de gradiente utilizado durante la capacitación: cuando se utiliza el modo `dense`, el optimizador calcula la matriz de gradiente completa para la capa de integración de token aunque la mayoría de las filas de gradiente tengan un valor de cero. Cuando se usa el modo `sparse`, el optimizador solo almacena filas de gradientes que se están utilizando realmente en el minilote. Si desea que el algoritmo realice actualizaciones de gradientes diferidas, que calculan los gradientes solamente en las filas que no tienen el valor de cero y que aceleran la capacitación, especifique `row_sparse`. Si configura el valor en `row_sparse`, los valores disponibles para otros hiperparámetros se restringirán, tal y como se indica a continuación: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/object2vec-hyperparameters.html) **Opcional** Valores válidos: `dense` o `row_sparse` Valor predeterminado: `dense` |
| weight\$1decay | El parámetro de degradación ponderal utilizado para optimización. **Opcional** Valores válidos: 0 ≤ número flotante ≤ 10 000 Valor predeterminado: 0 (sin decadencia) |
# Ajuste de un modelo Object2Vec
El *ajuste de modelo automático*, también conocido como ajuste de hiperparámetros, encuentra la mejor versión de un modelo ejecutando muchas tareas que probar una serie de hiperparámetros en su conjunto de datos. Usted elige los hiperparámetros que pueden ajustarse, un rango de valores para cada uno de ellos y una métrica objetiva. Para la métrica objetiva, utilice una de las métricas que el algoritmo calcula. El ajuste de modelos automático busca los hiperparámetros elegidos para encontrar la combinación de valores que dan lugar a un modelo que optimiza la métrica objetivo.
Para obtener más información acerca del ajuste de modelos, consulte [Ajuste automático de modelos con IA SageMaker](automatic-model-tuning.md).
## Métricas calculadas por el algoritmo Object2Vec
El algoritmo Object2Vec tiene métricas de clasificación y regresión. El tipo `output_layer` determina qué métrica puede utilizar para ajuste del modelo automático.
### Métricas de regresor calculadas por el algoritmo Object2Vec
El algoritmo registra una métrica regresor de error cuadrático medio, que se calcula durante las pruebas y validación. Al ajustar el modelo para las tareas de regresión, elija esta métrica como el objetivo.
| Nombre de métrica | Description (Descripción) | Dirección de optimización |
| --- | --- | --- |
| test:mean\$1squared\$1error | Error cuadrado medio | Minimizar |
| validation:mean\$1squared\$1error | Error cuadrado medio | Minimizar |
### Métricas de clasificación calculadas por el algoritmo Object2Vec
El algoritmo Object2Vec notifica métricas de precisión y clasificación de entropía cruzada, que se calculan durante el ensayo y validación. Al ajustar el modelo para tareas de clasificación, elija una de estas métricas como objetivo.
| Nombre de métrica | Description (Descripción) | Dirección de optimización |
| --- | --- | --- |
| test:accuracy | Exactitud | Maximizar |
| test:cross\$1entropy | Entropía cruzada | Minimizar |
| validation:accuracy | Exactitud | Maximizar |
| validation:cross\$1entropy | Entropía cruzada | Minimizar |
## Hiperparámetros ajustables de Object2Vec
Puede ajustar los siguientes hiperparámetros para el algoritmo Object2Vec.
| Nombre del hiperparámetro | Tipo de hiperparámetro | Rangos y valores recomendados |
| --- | --- | --- |
| dropout | ContinuousParameterRange | MinValue: 0.0,: 1.0 MaxValue |
| 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, 8192 MaxValue |
| 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 datos para la capacitación de Object2Vec
Cuando entrene con el algoritmo Object2Vec, asegúrese de que los datos de entrada de la solicitud estén en formato de líneas JSON, donde cada línea representa un único punto de datos.
## Entrada: formato de solicitud de líneas de JSON
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" son las entradas para encoder0 y encoder1, respectivamente. El mismo formato es válido tanto para clasificación como para problemas de regresión. Para la regresión, el campo `"label"` puede aceptar entradas con valores reales.
# Formato de datos para inferencia de Object2Vec
En la siguiente página se describen los formatos de solicitud de entrada y respuesta de salida para obtener inferencias de puntuación a partir del modelo Object2Vec de Amazon SageMaker AI.
## Optimización de GPU: clasificación o regresión
Debido a la escasez de memoria de GPU, la variable de entorno `INFERENCE_PREFERRED_MODE` se puede especificar para su optimización en cuanto a si la red de inferencia [Salida: integraciones de codificador](object2vec-encoder-embeddings.md#object2vec-out-encoder-embeddings-data) se carga en GPU. Si la mayor parte de su inferencia está destinada a su clasificación o regresión, especifique `INFERENCE_PREFERRED_MODE=classification`. El siguiente es un ejemplo de Batch Transform en el que se utilizan 4 instancias de p3.2xlarge que se optimizan para la inferencia: 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 de solicitud de clasificación o regresión
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 clasificación, la longitud del vector de puntuaciones corresponde a `num_classes`. Para problemas de regresión, la longitud es 1.
## Salida: formato de respuesta de regresión o clasificación
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]}
```
En los formatos de clasificación y de regresión, las puntuaciones se aplican a etiquetas individuales.
# Integraciones de codificador para Object2Vec
En la siguiente página se enumeran los formatos de solicitud de entrada y respuesta de salida para obtener la inferencia de incrustación del codificador a partir del modelo Object2Vec de Amazon SageMaker AI.
## Optimización de GPU: integraciones de codificador
Una integración es una asignación de objetos discretos, como palabras, a vectores de números reales.
Debido a la escasez de memoria de GPU, la variable de entorno `INFERENCE_PREFERRED_MODE` se puede especificar para su optimización en cuanto a si [Formato de datos para inferencia de Object2Vec](object2vec-inference-formats.md) o la red de inferencia de integración de codificador se carga en GPU. Si la mayor parte de su inferencia está destinada a las integraciones de codificador, especifique `INFERENCE_PREFERRED_MODE=embedding`. A continuación se muestra un ejemplo de transformación por lotes de cómo utilizar 4 instancias de p3.2xlarge, que se optimiza para la inferencia de integración 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: integraciones de codificador
Tipo de contenido: application/json; infer\$1max\$1seqlens=,
Donde y son enteros en el intervalo [1,5000] y definen la longitud máxima de la secuencia para el codificador hacia adelante y hacia atrá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]}
]
}
```
Tipo de contenido: application/jsonlines; infer\$1max\$1seqlens=,
Donde y son enteros en el intervalo [1,5000] y definen la longitud máxima de la secuencia para el codificador hacia adelante y hacia atrá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]}
```
En ambos formatos, debe especificar solo un único tipo de entrada: `“in0”` o `“in1.”` Luego el servicio de inferencia invoca al codificador correspondiente y produce las integraciones para cada una de las instancias.
## Salida: integraciones 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]}
```
La longitud del vector de la salida de integraciones por el servicio de inferencia es igual al valor de uno de los hiperparámetros siguientes, que usted especifica en el momento de la capacitación: `enc0_token_embedding_dim`, `enc1_token_embedding_dim` o `enc_dim`.