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.
# Algoritmos de SageMaker IA integrados para datos de texto
SageMaker La IA proporciona algoritmos que se adaptan al análisis de documentos textuales utilizados en el procesamiento del lenguaje natural, la clasificación o el resumen de documentos, el modelado o clasificación de temas y la transcripción o traducción en idiomas.
+ [BlazingText algoritmo](blazingtext.md): una implementación muy optimizada del Word2vec y de los algoritmos de clasificación de textos que se adapta fácilmente a grandes conjuntos de datos. Resulta útil para muchas tareas de salida en el procesamiento de lenguaje natural (NLP).
+ [Algoritmo Asignación latente de Dirichlet (LDA)](lda.md): este algoritmo es idóneo para determinar temas en un conjunto de documentos. Se trata de un *algoritmo no supervisado*, lo que significa que no utiliza datos de ejemplo con respuestas durante la capacitación.
+ [Algoritmo de Modelo de tema neuronal (NTM)](ntm.md): otra técnica no supervisada para determinar temas en un conjunto de documentos, con una estrategia de redes neuronales.
+ [Algoritmo Object2Vec](object2vec.md): un algoritmo de incrustación neuronal genérico que se puede utilizar para sistemas de recomendación, así como para la clasificación de documentos y la incrustación de frases.
+ [Sequence-to-Sequence Algoritmo](seq-2-seq.md): un algoritmo supervisado que se utiliza normalmente para la traducción automática neuronal.
+ [Clasificación de textos - TensorFlow](text-classification-tensorflow.md): un algoritmo supervisado para el aprendizaje por transferencia con modelos prentrenados disponibles para la clasificación de textos.
| Nombre de algoritmo | Nombre de canal | Modo de entrada de capacitación | Tipo de archivo | Clase de instancia | Paralelizable |
| --- | --- | --- | --- | --- | --- |
| BlazingText | capacitación | Archivo o canalización | Archivo de texto (una frase por línea con tokens separados por espacios) | GPU (solo instancia única) o CPU | No |
| LDA | capacitación y prueba (opcional) | Archivo o canalización | recordIO-protobuf o CSV | CPU (solo instancia única) | No |
| Modelo de temas neuronal | capacitación y validación (opcional), prueba o ambos | Archivo o canalización | recordIO-protobuf o CSV | GPU o CPU | Sí |
| Object2Vec | capacitación y validación (opcional), prueba o ambos | Archivos | Líneas de JSON | GPU o CPU (solo instancia única) | No |
| Modelo Seq2Seq | capacitación, validación y vocabulario | Archivos | recordIO-protobuf | GPU (solo instancia única) | No |
| Clasificación de textos - TensorFlow | entrenamiento y validación | Archivos | CSV | CPU o GPU | Sí (solo en varios casos GPUs en una sola instancia) |
# BlazingText algoritmo
El BlazingText algoritmo Amazon SageMaker AI proporciona implementaciones altamente optimizadas de los algoritmos Word2vec y de clasificación de texto. El algoritmo Word2vec es útil para muchas tareas de procesamiento de lenguaje natural (NLP) posteriores, como por ejemplo, análisis del sentimiento de reconocimiento de entidad nombrada, traducción automática, etc. La clasificación de texto es una tarea importante para las aplicaciones que realizan búsquedas web, recuperación de información, funciones de clasificación y clasificación de documentos.
El algoritmo Word2vec asigna palabras a vectores distribuidos de alta calidad. La representación vectorial resultante de una palabra se denomina una *incrustación de palabra*. Las palabras similares desde el punto de vista semántico corresponden a vectores que se acercan entre sí. De esta forma, las incrustaciones de palabras capturan relaciones semánticas entre palabras.
Muchas aplicaciones de procesamiento de lenguaje natural (NLP) aprenden incrustaciones de palabras mediante la capacitación con grandes colecciones de documentos. Estas representaciones vectoriales con capacitación previa proporcionan información sobre semántica y distribuciones de palabras que normalmente mejora la capacidad de generalización de otros modelos que se capacitan posteriormente en una cantidad de datos más limitada. La mayoría de las implementaciones del algoritmo Word2vec está optimizada para arquitecturas de CPU de varios núcleos. Esto dificulta el escalado de conjuntos de datos de gran tamaño.
Con el BlazingText algoritmo, puede escalar fácilmente grandes conjuntos de datos. Al igual que Word2vec, proporciona las arquitecturas de formación continua bag-of-words (CBOW) y Skip-gram. BlazingText[La implementación del algoritmo de clasificación de texto supervisado de varias clases y etiquetas amplía el clasificador de texto FastText para utilizar la aceleración de la GPU con núcleos CUDA personalizados.](https://docs.nvidia.com/cuda/index.html) Puede capacitar un modelo en más de mil millones de palabras en un par de minutos mediante una CPU de varios núcleos o una GPU. Además, se consigue un rendimiento similar al de los algoritmos de clasificación de texto de aprendizaje profundo state-of-the-art.
El BlazingText algoritmo no es paralelizable. Para obtener más información sobre los parámetros relacionados con el entrenamiento, consulte [Rutas de registro de Docker](https://docs.aws.amazon.com/en_us/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html) para algoritmos integrados. SageMaker
Los BlazingText algoritmos de SageMaker IA ofrecen las siguientes funciones:
+ Capacitación acelerada del clasificador de texto FastText en varios núcleos CPUs o en una GPU y de Word2Vec sobre el uso de núcleos CUDA altamente optimizados. GPUs [Para obtener más información, consulte: Escalar y acelerar BlazingText Word2Vec con varios. GPUs](https://dl.acm.org/citation.cfm?doid=3146347.3146354)
+ [Enriched Word Vectors with Subword Information](https://arxiv.org/abs/1607.04606) mediante el aprendizaje de las representaciones vectoriales para n-gramas de caracteres. Este enfoque permite generar vectores significativos para palabras out-of-vocabulary (OOV) BlazingText al representar sus vectores como la suma de los vectores de n-gramas (subpalabras) de caracteres.
+ Un `mode` `batch_skipgram` para el algoritmo Word2Vec que permite una computación distribuida y una capacitación más rápidas en varios nodos de CPU. El `mode` (modo) `batch_skipgram` crea minilotes mediante la estrategia de uso compartido de muestra negativa para convertir operaciones BLAS de nivel 1 en operaciones BLAS de nivel 3. Esto utiliza de manera eficiente las instrucciones de multiplicación-adición de las arquitecturas modernas. Para obtener más información, consulte [Paralelización de Word2Vec en la memoria compartida y distribuida](https://arxiv.org/pdf/1604.04661.pdf).
En resumen, los siguientes modos son compatibles con distintos tipos de instancias BlazingText :
| Modos | Word2Vec (Aprendizaje no supervisado) | Clasificación de textos (Aprendizaje supervisado) |
| --- | --- | --- |
| Instancia de CPU individual | `cbow` `Skip-gram` `Batch Skip-gram` | `supervised` |
| Instancia de GPU única (con 1 o más GPUs) | `cbow` `Skip-gram` | `supervised` con una GPU |
| Varias instancias de CPU | Batch Skip-gram | Ninguno |
Para obtener más información sobre las matemáticas subyacentes BlazingText, consulte [BlazingText: Escalar y acelerar Word2Vec](https://dl.acm.org/citation.cfm?doid=3146347.3146354) con varios. GPUs
**Topics**
+ [Interfaz de entrada/salida para el algoritmo BlazingText](#bt-inputoutput)
+ [Recomendación de instancia EC2 para el algoritmo BlazingText](#blazingtext-instances)
+ [BlazingText Ejemplos de cuadernos](#blazingtext-sample-notebooks)
+ [BlazingText Hiperparámetros](blazingtext_hyperparameters.md)
+ [Ajuste un modelo BlazingText](blazingtext-tuning.md)
## Interfaz de entrada/salida para el algoritmo BlazingText
El BlazingText algoritmo espera un único archivo de texto preprocesado con fichas separadas por espacios. Cada línea del archivo debe contener una sola frase. Si necesita capacitar en varios archivos de texto, concaténelos en un archivo y cargue el archivo en el canal correspondiente.
### Entrenamiento y validación del formato de datos
#### Entrenamiento y validación del formato de datos para el algoritmo Word2Vec
Para la capacitación de Word2Vec, cargue el archivo bajo el canal *train (capacitar)*. No se admite ningún otro canal. El archivo debe contener una frase de capacitación en cada línea.
#### Entrenamiento y validación del formato de datos para el algoritmo de clasificación de textos
Para el modo supervisado puede capacitar con el modo de archivo o con el formato de texto de manifiesto aumentado.
##### Capacitación con modo de archivo
Para el `supervised` modo, el training/validation archivo debe contener una oración de entrenamiento por línea junto con las etiquetas. Las etiquetas son palabras que contienen el prefijo de la cadena *\$1\$1label\$1\$1*. A continuación, se muestra un ejemplo de training/validation archivo:
```
__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**
El orden de las etiquetas dentro de la frase no importa.
Cargue el archivo de capacitación bajo el canal de capacitación y, de forma opcional, cargue el archivo de validación bajo el canal de validación.
##### Capacitación con formato de texto de manifiesto aumentado
El modo supervisado para instancias de CPU también admite el formato de manifiesto aumentado, lo que le permite hacer el entrenamiento en modo de canalización sin necesidad de crear archivos RecordIO. Cuando utilice el formato, es necesario generar un archivo de manifiesto de S3 que contiene la lista de frases y sus etiquetas correspondientes. El formato del archivo de manifiesto debe tener el formato [líneas de JSON](http://jsonlines.org/) en el que cada línea representa una muestra. Las frases se especifican utilizando la etiqueta `source` y la etiqueta se puede especificar con la etiqueta `label`. Deben proporcionarse ambas etiquetas, `source` y `label`, bajo el valor del parámetro `AttributeNames` tal y como se especifica en la solicitud.
```
{"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}
```
El entrenamiento de etiquetas múltiples también se admite mediante la especificación de una matriz de JSON de etiquetas.
```
{"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 obtener más información sobre archivos de manifiesto aumentado, consulte [Archivos de manifiesto aumentados para trabajos de entrenamiento](augmented-manifest.md).
### Inferencia y artefactos de modelo
#### Artefactos de modelo para el algoritmo Word2Vec
Para el aprendizaje de Word2Vec, los artefactos del modelo consisten en *vectors.txt*, que contiene el words-to-vectors mapeo, y *vectors.bin*, un binario que se utiliza BlazingText para el alojamiento, la inferencia o ambos. *vectors.txt* almacena los vectores en un formato compatible con otras herramientas, como Gensim y Spacy. Por ejemplo, un usuario de Gensim puede ejecutar los siguientes comandos para cargar el archivo 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())
```
Si el parámetro de evaluación se establece como `True`, se crea un archivo adicional, *eval.json*. Este archivo contiene los resultados de evaluación de similitud (mediante coeficientes de correlación de clasificación de Spearman) en el conjunto de datos de WS-353. El número de palabras del conjunto de datos WS-353 que no están en el cuerpo de capacitación se notifican.
Para solicitudes de inferencia, el modelo acepta un archivo JSON que contiene una lista de cadenas y devuelve una lista de vectores. Si la palabra no se encuentra en vocabulario, la inferencia devuelve un vector de ceros. Si las subpalabras se configuran `True` durante el entrenamiento, el modelo puede generar vectores para palabras out-of-vocabulary (OOV).
##### Ejemplo de solicitud JSON
Tipo MIME:` application/json`
```
{
"instances": ["word1", "word2", "word3"]
}
```
#### Artefactos de modelo para el algoritmo de clasificación de texto
El entrenamiento con resultados supervisados crea un archivo *model.bin* que el alojamiento puede consumir. BlazingText A modo de inferencia, el BlazingText modelo acepta un archivo JSON que contiene una lista de oraciones y devuelve una lista de las etiquetas pronosticadas y las puntuaciones de probabilidad correspondientes. Se espera que cada frase sea una cadena con tokens separados por espacios, palabras o ambos.
##### Ejemplo de solicitud JSON
Tipo MIME:` application/json`
```
{
"instances": ["the movie was excellent", "i did not like the plot ."]
}
```
De forma predeterminada, el servidor devuelve solo una predicción, la que tiene mayor probabilidad. Para recuperar las principales predicciones *k*, puede establecer *k* en la configuración, tal y como se indica a continuación:
```
{
"instances": ["the movie was excellent", "i did not like the plot ."],
"configuration": {"k": 2}
}
```
Para BlazingText, los `accept` parámetros ` content-type` y deben ser iguales. Para transformar por lotes, es necesario que ambos sean `application/jsonlines`. Si son diferentes, el campo `Accept` no se tiene en cuenta. Se muestra a continuación el formato para la 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}
```
Se muestra a continuación el formato para la salida:
```
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"]}
```
Tanto para el modo supervisado (clasificación de texto) como para el no supervisado (Word2Vec), FastText puede BlazingText consumir de forma cruzada los binarios (*\$1.bin*) generados por FastText y viceversa. Puede utilizar binarios generados BlazingText por FastText. Del mismo modo, puede alojar los binarios del modelo creados con BlazingText FastText utilizando.
A continuación, se muestra un ejemplo de cómo utilizar un modelo generado BlazingText con 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
```
Sin embargo, los binarios solo se admiten cuando se capacita en CPU y GPU única; la capacitación en Multi-GPU no producirá binarios.
## Recomendación de instancia EC2 para el algoritmo BlazingText
Para los `skipgram` modos `cbow` y, BlazingText admite instancias de una sola CPU y una sola GPU. Ambos modos son compatibles con el aprendizaje de incrustaciones de `subwords`. Para conseguir la máxima velocidad sin comprometer la precisión, recomendamos que utilice una instancia ml.p3.2xlarge.
Para `batch_skipgram` el modo, BlazingText admite instancias de CPU únicas o múltiples. Cuando entrenes en varias instancias, establece el valor del `S3DataDistributionType` campo del [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)al que pases`FullyReplicated`. BlazingTextse encarga de distribuir los datos entre las máquinas.
Para el modo de clasificación de texto supervisado, se recomienda una instancia C5 si el conjunto de datos de capacitación es inferior a 2 GB. Para conjuntos de datos más grandes, usa una instancia con una sola GPU. BlazingText admite instancias P2, P3, G4dn y G5 para el entrenamiento y la inferencia.
## BlazingText Ejemplos de cuadernos
Para ver un ejemplo de cuaderno que entrena e implementa el BlazingText algoritmo de SageMaker IA para generar vectores de palabras, consulte [Aprender las representaciones de palabras de Word2Vec mediante](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/blazingtext_word2vec_text8/blazingtext_word2vec_text8.html). BlazingText Para obtener instrucciones sobre cómo crear instancias de Jupyter Notebook y acceder a ellas, que puede utilizar para ejecutar el ejemplo en IA, consulte. SageMaker [Instancias de Amazon SageMaker Notebook](nbi.md) Tras crear y abrir una instancia de bloc de notas, selecciona la pestaña **Ejemplos de SageMaker IA** para ver una lista de todos los ejemplos de SageMaker IA. Los blocs de notas de muestra de modelado de temas que utilizan Blazing Text se encuentran situados en la sección de **Introduction a algoritmos de Amazon **. Para abrir un cuaderno, elija su pestaña **Usar** y, a continuación, elija **Crear copia**.
# BlazingText Hiperparámetros
Cuando inicie un trabajo de capacitación con una solicitud `CreateTrainingJob`, especifique un algoritmo de capacitación. También puede especificar hiperparámetros específicos del algoritmo como mapas. string-to-string Los hiperparámetros del BlazingText algoritmo dependen del modo que utilice: Word2Vec (sin supervisión) y Clasificación de texto (supervisado).
## Hiperparámetros de Word2Vec
En la siguiente tabla se enumeran los hiperparámetros del algoritmo de entrenamiento BlazingText Word2Vec proporcionado por Amazon AI. SageMaker
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| mode | La arquitectura de Word2vec se utiliza para la capacitación. **Obligatorio** Valores válidos: `batch_skipgram`, `skipgram` o `cbow` |
| batch\$1size | El tamaño de cada lote cuando `mode` se establece en `batch_skipgram`. Establezca un número entre 10 y 20. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 11 |
| buckets | La cantidad de buckets hash que se va a utilizar para subunidades de palabras. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 2000000 |
| epochs | El número de pasadas completas en los datos de capacitación. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 5 |
| evaluation | [Si el modelo entrenado se evalúa mediante la prueba -353. WordSimilarity](http://www.gabrilovich.com/resources/data/wordsim353/wordsim353.html) **Opcional** Valores válidos: (booleano) `True` o `False` Valor predeterminado: `True` |
| learning\$1rate | El tamaño del paso usado para actualizaciones de parámetros. **Opcional** Valores válidos: número flotante positivo Valor predeterminado: 0.05 |
| min\$1char | El número mínimo de caracteres que se va a utilizar para n-gramas de subunidades de palabras/caracteres. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 3 |
| min\$1count | Las palabras que aparecen menos de `min_count` veces se descartan. **Opcional** Valores válidos: número entero no negativo Valor predeterminado: 5 |
| max\$1char | El número máximo de caracteres que se va a utilizar para n-gramas de subunidades de palabras/caracteres **Opcional** Valores válidos: número entero positivo Valor predeterminado: 6 |
| negative\$1samples | El número de muestras negativas para la estrategia de uso compartido de muestra negativa. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 5 |
| sampling\$1threshold | El umbral para las apariciones de palabras. Las palabras que aparecen con mayor frecuencia en los datos de capacitación se muestrea de forma aleatoria. **Opcional** Valores válidos: fracción positiva. El intervalo recomendado es (0, 1e-3] Valor predeterminado: 0.0001 |
| subwords | Para decidir si aprender incrustaciones de subunidades de palabras o no. **Opcional** Valores válidos: (booleano) `True` o `False` Valor predeterminado: `False` |
| vector\$1dim | La dimensión de los vectores de palabras que aprende el algoritmo. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 100 |
| window\$1size | El tamaño de la ventana de contexto. La ventana de contexto es el número de palabras alrededor de la palabra de destino utilizada para la capacitación. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 5 |
## Hiperparámetros de clasificación de texto
En la siguiente tabla se enumeran los hiperparámetros del algoritmo de entrenamiento de clasificación de textos proporcionado por Amazon SageMaker AI.
**nota**
Aunque algunos de los parámetros son comunes entre los modos de clasificación de texto y Word2Vec, es posible que tenga significados diferentes en función del contexto.
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| mode | El modo de capacitación. **Obligatorio** Valores válidos: `supervised` |
| buckets | La cantidad de buckets hash que se va a utilizar para n-gramas de palabras. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 2000000 |
| early\$1stopping | Decidir si detener la capacitación si la precisión de validación no mejora después de un número de fechas de inicio de `patience`. Tenga en cuenta que se requiere un canal de validación si se utiliza una parada temprana. **Opcional** Valores válidos: (booleano) `True` o `False` Valor predeterminado: `False` |
| epochs | El número máximo de pasadas completas en los datos de capacitación. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 5 |
| learning\$1rate | El tamaño del paso usado para actualizaciones de parámetros. **Opcional** Valores válidos: número flotante positivo Valor predeterminado: 0.05 |
| min\$1count | Las palabras que aparecen menos de `min_count` veces se descartan. **Opcional** Valores válidos: número entero no negativo Valor predeterminado: 5 |
| min\$1epochs | El número mínimo de fechas de inicio que debe capacitarse antes de invocar la lógica de detención temprana. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 5 |
| patience | El número de fechas de inicio que se debe esperar antes de la aplicación de la detención temprana cuando no se produce ningún avance en el conjunto de validación. Solo se usa cuando `early_stopping` es `True`. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 4 |
| vector\$1dim | La dimensión de la capa de integración. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 100 |
| word\$1ngrams | El número de características de n-gramas de palabras que se va a utilizar. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 2 |
# Ajuste un modelo BlazingText
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. Puede elegir la métrica objetiva de las métricas que el algoritmo computa. El ajuste de modelo automático busca los hiperparámetros elegidos para encontrar la combinación de valores que obtienen el modelo que optimiza la métrica objetiva.
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 BlazingText
El algoritmo BlazingText Word2Vec (`skipgram``cbow`, y los `batch_skipgram` modos) informa sobre una sola métrica durante el entrenamiento:. `train:mean_rho` Esta métrica se computa en [conjuntos de datos de WS-353 de similitud de palabras](https://aclweb.org/aclwiki/WordSimilarity-353_Test_Collection_(State_of_the_art)). Al ajustar los valores del hiperparámetro para el algoritmo Word2Vec, utilice esta métrica como la métrica objetiva.
El algoritmo de clasificación de BlazingText textos (`supervised`modo) también informa sobre una única métrica durante el entrenamiento: la. `validation:accuracy` Al ajustar los valores del hiperparámetro para el algoritmo de clasificación de texto, utilice estas métricas como la métrica objetiva.
| Nombre de métrica | Description (Descripción) | Dirección de optimización |
| --- | --- | --- |
| train:mean\$1rho | La ro media (coeficiente de correlación de clasificación de Spearman) en [conjuntos de datos de WS-353 de similitud de palabras](http://alfonseca.org/pubs/ws353simrel.tar.gz) | Maximizar |
| validation:accuracy | La precisión de clasificación en el conjunto de datos de validación especificado por el usuario | Maximizar |
## Hiperparámetros ajustables BlazingText
### Hiperparámetros ajustables para el algoritmo Word2Vec
Ajuste un modelo BlazingText Word2Vec de Amazon SageMaker AI con los siguientes hiperparámetros. Los hiperparámetros con el mayor impacto en métricas objetivas de Word2Vec son: `mode`, ` learning_rate`, `window_size`, `vector_dim` y `negative_samples`.
| Nombre del parámetro | Tipo de parámetro | Rangos o valores recomendados |
| --- | --- | --- |
| batch\$1size | `IntegerParameterRange` | [8-32] |
| epochs | `IntegerParameterRange` | [5-15] |
| learning\$1rate | `ContinuousParameterRange` | MinValue: 0,005,: 0,01 MaxValue |
| 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 ajustables para el algoritmo de clasificación de texto
Ajuste un modelo de clasificación de BlazingText texto de Amazon SageMaker AI con los siguientes hiperparámetros.
| Nombre del parámetro | Tipo de parámetro | Rangos o 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 Asignación latente de Dirichlet (LDA)
El algoritmo Latent Dirichlet Allocation (LDA) de Amazon SageMaker AI es un algoritmo de aprendizaje no supervisado que intenta describir un conjunto de observaciones como una mezcla de distintas categorías. LDA se utiliza normalmente para detectar un número especificado por el usuario de temas compartidos por los documentos dentro de un cuerpo de textos. Aquí, cada observación es un documento, las características son la presencia (o recuento de apariciones) de cada palabra y las categorías son los temas. Puesto que el método no se supervisa, los temas no se especifican inicialmente y no se garantiza que se sigan los procedimientos de categorización naturales de los documentos. Los temas se aprenden como una distribución de probabilidad a través de las palabras que se generan en cada documento. Cada documento, a su vez, se describe como una combinación de temas.
El contenido exacto de dos documentos con combinaciones de temas similares no será el mismo. Sin embargo, en general, se puede esperar que estos documentos usen con más frecuencia un subconjunto compartido de palabras que cuando se compara con un documento de una combinación de temas diferentes. Esto permite a LDA detectar estos grupos de palabras y utilizaros para formar temas. A continuación mostramos un ejemplo muy sencillo, a partir de un conjunto de documentos en los que las únicas palabras que aparecen en ellos son: *comer*, *dormir*, *jugar*, *maullar* y *ladrar*, LDA produciría temas como estos:
| **Tema** | *comer* | *dormir* | *jugar* | *maullar* | *ladrar* |
| --- | --- | --- | --- | --- | --- |
| Tema 1 | 0.1 | 0.3 | 0.2 | 0.4 | 0.0 |
| Tema 2 | 0.2 | 0.1 | 0.4 | 0.0 | 0.3 |
Puede deducir que los documentos que tienen una mayor probabilidad de formar parte del Tema 1 tienen que ver con los gatos (que es más probable que *maúllen* y *duerman*) y es más probable que los documentos que formen parte del tema 2 tengan que ver con los perros (que prefieren *jugar* y *ladrar*). Puede encontrar estos temas a pesar de que las palabras "perro" y "gato" no aparezcan nunca en ninguno de los textos.
**Topics**
+ [Elección entre Latent Dirichlet Allocation (LDA) y Neural Topic Model (NTM)](#lda-or-ntm)
+ [Interfaz de entrada/salida para el algoritmo LDA](#lda-inputoutput)
+ [Recomendación de la instancia EC2 para el algoritmo LDA](#lda-instances)
+ [Cuadernos de muestra de LDA](#LDA-sample-notebooks)
+ [Funcionamiento de LDA](lda-how-it-works.md)
+ [Hiperparámetros de LDA](lda_hyperparameters.md)
+ [Ajustar un modelo LDA](lda-tuning.md)
## Elección entre Latent Dirichlet Allocation (LDA) y Neural Topic Model (NTM)
Los modelos temáticos se utilizan comúnmente para producir temas a partir de corpus que (1) encapsulan de manera uniforme el significado semántico y (2) describen bien los documentos. Por lo tanto, los modelos de temas tienen como objetivo minimizar la perplejidad y maximizar la uniformidad de los temas.
La perplejidad es una métrica intrínseca de evaluación del modelado del lenguaje que mide la inversa de la probabilidad media geométrica por palabra en los datos de la prueba. Una puntuación de perplejidad más baja indica un mejor rendimiento de generalización. Las investigaciones han demostrado que la probabilidad calculada por palabra a menudo no se ajusta al juicio humano, y puede no estar correlacionada en absoluto, por lo que se ha introducido la uniformidad temática. Cada tema deducido del modelo consta de palabras, y la uniformidad entre los temas se calcula con las N palabras principales del modelo para ese tema concreto. Suele definirse como el promedio o la mediana de las puntuaciones de similitud de palabras por pares de las palabras de ese tema; por ejemplo, información mutua puntual (PMI). Un modelo prometedor genera temas uniformes o temas con puntuaciones altas de uniformidad temática.
Si bien el objetivo es formar un modelo temático que minimice la perplejidad y maximice la uniformidad temática, a menudo existe un equilibrio entre el LDA y el NTM. Una investigación reciente de Amazon (Dinget y otros, 2018) ha demostrado que el NTM puede lograr una alta uniformidad temática, pero el LDA, entrenado con un muestreo fragmentado de Gibbs, logra una mayor perplejidad. Existe un equilibrio entre la perplejidad y la uniformidad de los temas. Desde el punto de vista práctico, si hablamos de hardware y de potencia de computación, el hardware NTM de SageMaker es más flexible que el LDA y se puede escalar mejor, ya que NTM puede ejecutarse en la CPU y la GPU y se puede paralelizar en varias instancias de GPU, mientras que el LDA solo admite el entrenamiento con CPU en una sola instancia.
**Topics**
+ [Elección entre Latent Dirichlet Allocation (LDA) y Neural Topic Model (NTM)](#lda-or-ntm)
+ [Interfaz de entrada/salida para el algoritmo LDA](#lda-inputoutput)
+ [Recomendación de la instancia EC2 para el algoritmo LDA](#lda-instances)
+ [Cuadernos de muestra de LDA](#LDA-sample-notebooks)
+ [Funcionamiento de LDA](lda-how-it-works.md)
+ [Hiperparámetros de LDA](lda_hyperparameters.md)
+ [Ajustar un modelo LDA](lda-tuning.md)
## Interfaz de entrada/salida para el algoritmo LDA
LDA espera que se proporcionen datos sobre el canal de capacitación y admite de forma opcional un canal de prueba, que se puntúa mediante el modelo final. LDA es compatible con los formatos de archivo `recordIO-wrapped-protobuf` (denso y disperso) y `CSV`. Para `CSV`, los datos deben ser densos y tener la dimensión igual a *número de registros \$1 tamaño del vocabulario*. Es posible capacitar la LDA en File o Pipe al utilizar recordIO-wrapped protobuf, pero solo en modo de archivo para el formato `CSV`.
Para la inferencia, se admiten los tipos de contenido `text/csv`, `application/json` y `application/x-recordio-protobuf`. Es posible pasar los datos dispersos para `application/json` y `application/x-recordio-protobuf`. La inferencia de LDA devuelve predicciones `application/json` o `application/x-recordio-protobuf` **, que incluyen el vector `topic_mixture` para cada observación.
Para obtener más información sobre los formatos de capacitación e inferencia, consulte los [Cuadernos de muestra de LDA](#LDA-sample-notebooks).
## Recomendación de la instancia EC2 para el algoritmo LDA
Actualmente, LDA solo es compatible con la capacitación de CPU de una instancia. Se recomiendan las instancias de CPU para el alojamiento o la inferencia.
## Cuadernos de muestra de LDA
Para consultar un cuaderno de muestra donde se vea cómo entrenar al algoritmo Latent Dirichlet Allocation de SageMaker AI en un conjunto de datos y cómo implementar el modelo entrenado para realizar inferencias en las combinaciones de temas en 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 obtener instrucciones sobre cómo crear instancias de cuadernos de Jupyter que pueda utilizar para ejecutar el ejemplo en SageMaker AI, consulte [Instancias de Amazon SageMaker Notebook](nbi.md). Una vez que haya creado una instancia de cuaderno y la haya abierto, seleccione la pestaña **Ejemplos de SageMaker AI** para ver una lista de todas las muestras de SageMaker AI. Los blocs de notas de modelado de ejemplos que utilizan los algoritmos NTM se encuentran en la sección de **introducción a algoritmos de Amazon**. Para abrir un cuaderno, haga clic en la pestaña **Usar** y seleccione **Crear copia**.
# Funcionamiento de LDA
Amazon SageMaker AI LDA es un algoritmo de aprendizaje no supervisado que intenta describir un conjunto de observaciones como una combinación de categorías distintas. Estas categorías son por sí mismas una distribución de probabilidad sobre las características. LDA es un modelo de probabilidad generativo, lo que significa que intenta proporcionar un modelo para la distribución de salidas y entradas basado en variables latentes. Esto se opone a los modelos discriminatorios, que intentan aprender cómo mapear entradas en salidas.
Puede utilizar LDA para una serie de tareas, desde agrupar en clústeres clientes según las compras de productos hasta realizar un análisis armónico automático de la música. Sin embargo, normalmente se asocia al modelado de temas en los cuerpos de texto. Se hace referencia a las observaciones como documentos. Se hace referencia al conjunto de características como vocabulario. Se hace referencia a una característica como a una palabra. Se hace referencia a las categorías resultantes como temas.
**nota**
La lematización aumenta significativamente la precisión y el desempeño del algoritmo. Considere realizar el procesamiento previo de cualquier datos de texto de entrada. Para obtener más información, consulte [Stemming and lemmatization](https://nlp.stanford.edu/IR-book/html/htmledition/stemming-and-lemmatization-1.html).
El modelo LDA se define mediante dos parámetros:
+ α: una estimación anterior sobre la probabilidad del tema (es decir, la frecuencia media con la que aparece cada tema en un documento determinado).
+ β: una recopilación de temas k en los que a cada tema se le proporciona una distribución de probabilidad sobre el vocabulario utilizado en un cuerpo de documentos, a lo que también se le llama "distribución de tema-palabra".
LDA es un modelo "bolsa continua de palabras", que significa que el orden de las palabras no es significativo. LDA es una modelo generativo en el que se genera cada documento palabra por palabra eligiendo una combinación de temas θ ∼ Dirichlet(α).
Realice el siguiente procedimiento en cada palabra del documento:
+ Elegir un tema z ∼ Multinomial(θ)
+ Elija la distribución tema-palabra correspondiente β\$1z.
+ Dibuje una palabra w ∼ Multinomial(β\$1z).
Cuando se realiza la capacitación del modelo, el objetivo es encontrar los parámetros α y β, que maximizan la probabilidad de que el modelo genere el cuerpo de textos.
Los métodos más populares para la estimación del modelo LDA utilizan el muestreo Gibbs o las técnicas de maximización de expectativas (EM, del inglés Expectation Maximization). Amazon SageMaker AI LDA utiliza la descompensación espectral del tensor. Esto proporciona varias ventajas:
+ **Garantías teóricas sobre los resultados**. Se garantiza que el método EM estándar converge solo de forma óptima en local, que normalmente suele ser de poca calidad.
+ **Lamentablemente en paralelo**. El trabajo puede dividirse en documentos de entrada de inferencia y capacitación. Los enfoques de muestreo de Gibbs y método EM pueden paralelizarse, pero no tan fácilmente.
+ **Rápido**. Aunque el método EM dispone de un costo bajo de iteración, está preparado para velocidades bajas de convergencia. El muestreo de Gibbs está también sujeto a velocidades bajas de convergencia y también requiere un gran número de muestras.
En líneas generales, el algoritmo de descomposición del tensor sigue este proceso:
1. El objetivo es calcular la descomposición espectral de un tensor **V** x **V** x **V**, que resume los momentos de los documentos en nuestro corpus. **V** es el tamaño del vocabulario (es decir, el número de palabras distintas en todos los documentos). Los componentes espectrales de este tensor son los parámetros LDA α y β, que maximizan la probabilidad general del cuerpo de documentos. Sin embargo, puesto que el tamaño del vocabulario suele ser grande, este tensor **V** x **V** x **V** es demasiado grande para almacenarlo en memoria.
1. En su lugar, utiliza una matriz de momento **V** x **V**, que es la análoga bidimensional del tensor del paso 1, para buscar una matriz de blanqueamiento de la dimensión **V** x **k**. Esta matriz puede utilizarse para convertir la matriz de momento **V** x **V** en una matriz de identidad **k** x **k**. **k** es el número de temas en el modelo.
1. Esta misma matriz de blanqueamiento puede utilizarse para buscar un tensor **k** x **k** x **k** más pequeño. Cuando se descompone espectralmente, este tensor dispone de componentes que tienen una relación sencilla con los componentes del tensor **V** x **V** x **V**.
1. Los *mínimos cuadrados alternantes* se utilizan para descomponer el tensor **k** x *k* x **k** más pequeño. Esto proporciona una mejora sustancial en el consumo de memoria y la velocidad. Los parámetros α y β pueden encontrarse mediante el "desblanqueamiento" de estas salidas en la descomposición espectral.
Después de que se hayan encontrado los parámetros del modelo LDA, puede buscar las combinaciones de temas para cada documento. Utilice Stochastic Gradient Descent para optimizar la función de probabilidad de la observación de una combinación de temas determinada correspondiente a estos datos.
La calidad de los temas se puede mejorar aumentando el número de temas que buscar en una capacitación y, a continuación, filtrando los que tienen una peor calidad. De hecho, esto se hace de forma automática en SageMaker AI LDA: se procesa un 25 % más de temas y solo se devuelven los que tienen las distribuciones a priori de Dirichlet de mayor tamaño asociadas. Para realizar un análisis y filtrado del tema más avanzado, puede aumentar el recuento de temas y modificar el modelo LDA resultante de la siguiente manera:
```
> 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 obtener información sobre los algoritmos de LDA y la implementación de SageMaker AI, consulte los siguientes documentos:
+ Animashree Anandkumar, Rong Ge, Daniel Hsu, Sham M Kakade y Matus Telgarsky. *Tensor Decompositions for Learning Latent Variable Models*, Journal of Machine Learning Research, 15:2773–2832, 2014.
+ David M Blei, Andrew Y Ng y Michael I Jordan. *Asignación latente de Dirichlet (LDA)* Journal of Machine Learning Research, 3(ene):993–1022, 2003.
+ Thomas L Griffiths y Mark Steyvers. *Finding Scientific Topics*. Proceedings of the National Academy of Sciences, 101(supl. 1):5228–5235, 2004.
+ Tamara G Kolda y Brett W Bader. *Tensor Decompositions and Applications*. SIAM Review, 51(3):455–500, 2009.
# Hiperparámetros de LDA
En la solicitud `CreateTrainingJob`, especifique el algoritmo de capacitación. También puede especificar hiperparámetros específicos de algoritmos como mapeos de cadena a cadena. En la siguiente tabla, aparecen los hiperparámetros para el algoritmo de entrenamiento LDA proporcionado por Amazon SageMaker AI. Para obtener más información, consulte [Funcionamiento de LDA](lda-how-it-works.md).
| Nombre del parámetro | Descripción |
| --- | --- |
| num\$1topics | El número de temas de LDA para buscar en los datos. **Obligatorio** Valores válidos: número entero positivo |
| feature\$1dim | El tamaño del vocabulario del cuerpo de documentos de entrada. **Obligatorio** Valores válidos: número entero positivo |
| mini\$1batch\$1size | El número total de documentos en el cuerpo de documentos de entrada. **Obligatorio** Valores válidos: número entero positivo |
| alpha0 | Suposición inicial del parámetro de concentración: la suma de los elementos de Dirichlet anterior. Es más probable que los valores pequeños generen combinaciones de temas dispersos y los valores grandes (superiores a 1,0) generen combinaciones más uniformes. **Opcional** Valores válidos: número flotante positivo Valor predeterminado: 1.0 |
| max\$1restarts | El número de reinicios que realizar durante la fase de descomposición espectral de mínimos cuadrados alternantes (ALS) del algoritmo. Se puede utilizar para buscar mejor el mínimo local de calidad a costa de una computación adicional, pero normalmente no debe ajustarse. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 10 |
| max\$1iterations | El número máximo de iteraciones que realizar durante la fase ALS del algoritmo. Se puede utilizar para buscar mejor el mínimo de calidad a costa de una computación adicional, pero normalmente no debe ajustarse. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 1000 |
| tol | Tolerancia a errores del destino para la fase ALS del algoritmo. Se puede utilizar para buscar mejor el mínimo de calidad a costa de una computación adicional, pero normalmente no debe ajustarse. **Opcional** Valores válidos: número flotante positivo Valor predeterminado: 1e-8 |
# Ajustar un modelo LDA
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. Puede elegir la métrica objetiva de las métricas que el algoritmo computa. El ajuste de modelo automático busca los hiperparámetros elegidos para encontrar la combinación de valores que obtienen el modelo que optimiza la métrica objetiva.
LDA es un algoritmo de modelado de temas no supervisado que intenta describir un conjunto de observaciones (documentos) como una combinación de categorías (temas) distintas. La métrica "probabilidad de registro por palabra" (PWLL) mide la probabilidad de que un conjunto de temas aprendidos (un modelo LDA) describe de forma precisa un conjunto de datos de documento de prueba. Valores más altos de PWLL indican que es más probable que los datos de prueba se describan en el modelo LDA.
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 LDA
El algoritmo LDA informa sobre en una única métrica durante la capacitación: `test:pwll`. Al ajustar un modelo, elija esta métrica como la métrica objetivo.
| Nombre de métrica | Descripción | Dirección de optimización |
| --- | --- | --- |
| test:pwll | Probabilidad de registro por palabra en el conjunto de datos de prueba. La probabilidad de que el conjunto de datos de prueba sea descrito con exactitud por el modelo aprendido LDA. | Maximizar |
## Hiperparámetros de LDA ajustables
Puede ajustar los siguientes hiperparámetros para el algoritmo de LDA. Los hiperparámetros `alpha0` y `num_topics` pueden afectar a la métrica objetivo LDA (`test:pwll`). Si aún no conoce los valores óptimos para estos hiperparámetros, que maximizan la probabilidad de registro por palabra y producen un modelo LDA preciso, un ajuste de modelo LDA automático puede ayudar a encontrarlos.
| Nombre del 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 tema neuronal (NTM)
Amazon SageMaker AI NTM es un algoritmo de aprendizaje no supervisado que se utiliza para organizar un corpus de documentos en *temas* que contienen agrupaciones de palabras en función de su distribución estadística. Los documentos que contienen presencias frecuentes de palabras como "moto", "coche", "tren", "distancia" y "velocidad", es probable que compartan un tema de "transporte", por ejemplo. El modelado de temas se puede utilizar para clasificar o resumir documentos en función de los temas detectados o para recuperar información o contenido recomendado en función de similitudes por tema. Los temas de documentos que aprende NTM son caracterizado como una *representación latente* porque los temas se infieren a partir de las distribuciones de palabras observadas en el corpus. La semántica de los temas se infiere normalmente mediante el examen de las palabras más importantes que contienen. Puesto que el método no es supervisado, se especifican previamente solo los números de temas, no los propios temas. Además, no se garantiza que los temas sigan los procedimientos de categorización naturales de los documentos.
Los modelos de temas proporcionan una forma de visualizar contenido de un gran cuerpo de documentos en términos de temas aprendidos. Los documentos relevantes para cada tema deben indexarse o buscarse en función de las etiquetas de temas blandas. Las representaciones latentes de documentos pueden utilizarse para buscar documentos similares en el espacio del tema. También puede utilizar las representaciones latentes de documentos que aprende el modelo del tema para la entrada en otro algoritmo supervisado como un clasificador de documentos. Puesto que se prevé que las representaciones latentes de documentos capturen la semántica de los documentos subyacentes, se espera que los algoritmos basados en parte en estas representaciones tengan un mejor rendimiento que los basados solo en características léxicas.
Si bien puede utilizar los algoritmos NTM y LDA de Amazon SageMaker AI para el modelado de temas, son algoritmos distintos y se espera que produzcan resultados diferentes en los mismos datos de entrada.
Para obtener más información sobre las operaciones matemáticas que se encuentran detrás de NTM, consulte [Inferencia variacional neuronal para el procesamiento de texto](https://arxiv.org/pdf/1511.06038.pdf).
**Topics**
+ [Interfaz de entrada/salida para el algoritmo NTM](#NTM-inputoutput)
+ [Recomendación de la instancia EC2 para el algoritmo NTM](#NTM-instances)
+ [Bloc de notas de muestra de NTM](#NTM-sample-notebooks)
+ [Hiperparámetros de NTM](ntm_hyperparameters.md)
+ [Ajustar un modelo NTM](ntm-tuning.md)
+ [Formatos de respuesta de NTM](ntm-in-formats.md)
## Interfaz de entrada/salida para el algoritmo NTM
El modelo de temas neuronales de Amazon SageMaker AI admite cuatro canales de datos: tren, validación, prueba y auxiliar. Los canales de datos de validación, prueba y auxiliar son opcionales. Si especifica cualquiera de estos canales opcionales, establezca el valor del `S3DataDistributionType` parámetro para ellos `FullyReplicated`. Si proporciona datos de validación, la pérdida en estos datos se registra en cada fecha de inicio y el modelo detiene la capacitación cuando detecta que esa pérdida de validación no mejora. Si no proporciona datos de validación, el algoritmo detiene los datos basados anteriormente en la capacitación, pero esto puede ser menos eficiente. Si proporciona datos de prueba, el algoritmo informa de la pérdida de prueba del modelo final.
Los canales de datos de capacitación, validación y prueba para NTM admiten `recordIO-wrapped-protobuf` (denso y disperso) y formatos de archivo `CSV`. Para el formato `CSV`, cada fila debe representarse densamente con recuentos de cero para las palabras no presentes en el documento correspondiente y tener la dimensión igual a: (número de registros) \$1 (tamaño de vocabulario). Puede usar el modo de archivo o el modo de canalización para capacitar modelos con datos con formato `recordIO-wrapped-protobuf` o `CSV`. El canal auxiliar se utiliza para suministrar un archivo de texto que contiene vocabulario. Al proporcionar el archivo de vocabulario, los usuarios pueden ver las palabras principales de cada uno de los temas impresas en el registro en lugar de su número entero IDs. Tener el archivo de vocabulario también permite a NTM calcular puntuaciones de Coherencia del tema de incrustación de palabra (WETC), una nueva métrica que se muestran en el registro que captura similitud entre las primeras palabras en cada tema de forma eficaz. La `ContentType` correspondiente al canal auxiliar es`text/plain`, en la que cada línea contiene una sola palabra, en el orden correspondiente al número entero IDs proporcionado en los datos. El archivo de vocabulario debe tener el nombre `vocab.txt` y actualmente solo se admite la codificación UTF-8.
Para la inferencia, se admiten los tipos de contenido `text/csv`, `application/json`, `application/jsonlines` y `application/x-recordio-protobuf`. Es posible pasar los datos dispersos para `application/json` y `application/x-recordio-protobuf`. La inferencia de NTM devuelve predicciones `application/json` o `application/x-recordio-protobuf` **, que incluyen el vector `topic_weights` para cada observación.
Consulte la entrada del [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 obtener más detalles sobre el uso del canal auxiliar y las puntuaciones del WETC. Para obtener más información acerca de cómo calcular la puntuación WETC, consulte [Modelado de temas neuronales consciente de la coherencia](https://arxiv.org/pdf/1809.02687.pdf). Usamos el WETC por pares descrito en este paper para el Amazon SageMaker AI Neural Topic Model.
Para obtener más información sobre los formatos de archivo de entrada y salida, consulte [Formatos de respuesta de NTM](ntm-in-formats.md) para inferencia y [Bloc de notas de muestra de NTM](#NTM-sample-notebooks).
## Recomendación de la instancia EC2 para el algoritmo NTM
La capacitación de NTM admite tanto los tipos de instancia de GPU como de CPU. Recomendamos las instancias de GPU, pero para determinadas cargas de trabajo, las instancias de CPU pueden generar costos de capacitación inferiores. Las instancias de CPU deben ser suficientes para la inferencia. El algoritmo NTM admite las familias de instancias de GPU P2, P3, G4dn y G5 para el entrenamiento y la inferencia.
## Bloc de notas de muestra de NTM
Para ver un ejemplo de cuaderno que utiliza el algoritmo NTM de SageMaker IA para descubrir temas en documentos a partir de una fuente de datos sintética en la que se conoce la distribución de los temas, consulte la [Introducción a las funciones básicas](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/ntm_synthetic/ntm_synthetic.html) de la NTM. Para obtener instrucciones sobre cómo crear instancias de Jupyter Notebook y acceder a ellas, que puede utilizar para ejecutar el ejemplo en IA, consulte. SageMaker [Instancias de Amazon SageMaker Notebook](nbi.md) Una vez que haya creado una instancia de bloc de notas y la haya abierto, seleccione la pestaña **Ejemplos de SageMaker IA** para ver una lista de todos los ejemplos de SageMaker IA. Los blocs de notas de modelado de ejemplos que utilizan los algoritmos NTM se encuentran en la sección de **introducción a algoritmos de Amazon**. Para abrir un cuaderno, haga clic en la pestaña **Usar** y seleccione **Crear copia**.
# Hiperparámetros de NTM
En la siguiente tabla se enumeran los hiperparámetros que puede configurar para el algoritmo Amazon SageMaker AI Neural Topic Model (NTM).
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| `feature_dim` | El tamaño del vocabulario del conjunto de datos. **Obligatorio** Valores válidos: número entero positivo (mín.: 1, máx.: 1,000,000) |
| num\$1topics | El número de temas necesarios. **Obligatorio** Valores válidos: número entero positivo (mín.: 2, máx.: 1000) |
| batch\$1norm | Si utilizar la normalización por lotes durante la capacitación. **Opcional** Valores válidos: *True* o *False* Valor predeterminado: *false* |
| clip\$1gradient | La magnitud máxima para cada componente de gradiente. **Opcional** Valores válidos: número flotante (mín.: 1e-3) Valor predeterminado: infinito |
| encoder\$1layers | El número de capas en el codificador y el tamaño de salida de cada capa. Cuando se establezca en *auto*, el algoritmo usará dos capas de tamaños 3 x `num_topics` y 2 x `num_topics` respectivamente. **Opcional** Valores válidos: lista separada por comas de números enteros positivos o *auto* Valor predeterminado: *auto* |
| encoder\$1layers\$1activation | La función de activación a utilizar en las capas del codificador. **Opcional** Valores válidos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/ntm_hyperparameters.html) Valor predeterminado: `sigmoid` |
| epochs | Número máximo de iteraciones en los datos de capacitación. **Opcional** Valores válidos: número entero positivo (mín.: 1) Valor predeterminado: 50 |
| learning\$1rate | La tasa de aprendizaje para el optimizador. **Opcional** Valores válidos: número flotante (mín.: 1e-6, máx.: 1,0) Valor predeterminado: 0.001 |
| mini\$1batch\$1size | El número de ejemplos en cada mini lote. **Opcional** Valores válidos: número entero positivo (mín.: 1, máx.: 10000) Valor predeterminado: 256 |
| num\$1patience\$1epochs | El número de fechas de inicio sucesivas en la que se evalúa el criterio de detención temprana. La detención temprana se activa cuando se produce el cambio en la función de pérdida cae por debajo del especificado `tolerance` en el último `num_patience_epochs` número de fechas de inicio. Para deshabilitar la detención temprana, establezca `num_patience_epochs` en un valor superior a `epochs`. **Opcional** Valores válidos: número entero positivo (mín.: 1) Valor predeterminado: 3 |
| optimizer | El optimizador a utilizar para la capacitación. **Opcional** Valores válidos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/ntm_hyperparameters.html) Valor predeterminado: `adadelta` |
| rescale\$1gradient | El factor de reescalado para el gradiente. **Opcional** Valores válidos: número flotante (mín.: 1e-3, máx.: 1,0) Valor predeterminado: 1.0 |
| sub\$1sample | La fracción de los datos de capacitación que se van a muestrear para capacitación por fecha de inicio. **Opcional** Valores válidos: número flotante (mín.: 0,0, máx.: 1,0) Valor predeterminado: 1.0 |
| tolerance | El cambio relativo máximo en la función de pérdida. La detención temprana se activa cuando se produce el cambio en la función de pérdida cae por debajo de este valor en el último `num_patience_epochs` número de fechas de inicio. **Opcional** Valores válidos: número flotante (mín.: 1e-6, máx.: 0,1) Valor predeterminado: 0.001 |
| weight\$1decay | El coeficiente de degradación de ponderación. Agrega la regularización L2. **Opcional** Valores válidos: número flotante (mín.: 0,0, máx.: 1,0) Valor predeterminado: 0,0 |
# Ajustar un modelo NTM
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. Puede elegir la métrica objetiva de las métricas que el algoritmo computa. El ajuste de modelo automático busca los hiperparámetros elegidos para encontrar la combinación de valores que obtienen el modelo que optimiza la métrica objetiva.
Amazon SageMaker AI NTM es un algoritmo de aprendizaje no supervisado que aprende las representaciones latentes de grandes colecciones de datos discretos, como un corpus de documentos. Las representaciones latentes usan variables inferidas que no se miden directamente para modelar las observaciones en un conjunto de datos. El ajuste de modelo automático en NTM le ayuda a encontrar el modelo que minimiza la pérdida sobre los datos de capacitación o de validación. *La pérdida de capacitación* mide la eficacia del modelo para encajar los datos de capacitación. *La pérdida de validación de* mide la eficacia del modelo para generalizar a datos en los que no está capacitado. Una pérdida de capacitación baja indica que un modelo es idóneo para los datos de capacitación. Una pérdida de validación baja indica que un modelo no ha sobreajustado los datos de entrenamiento y, por tanto, debería poder modelar correctamente documentos con los que no ha sido entrenado. Normalmente, es preferible que ambas pérdidas sean pequeñas. Sin embargo, minimizar demasiado la pérdida de capacitación podría dar lugar a sobreajustes y aumentar la pérdida de validación, lo que reduciría la generalidad del modelo.
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 NTM
El algoritmo NTM informa una única métrica que se calcula durante la capacitación: `validation:total_loss`. La pérdida total es la suma de la pérdida de reconstrucción y divergencia de Kullback-Leibler. Al ajustar los valores de hiperparámetro, elija esta métrica como el objetivo.
| Nombre de métrica | Description (Descripción) | Dirección de optimización |
| --- | --- | --- |
| validation:total\$1loss | Pérdida total en conjunto de validación | Minimizar |
## Hiperparámetros de NTM ajustables
Puede ajustar los siguientes hiperparámetros para el algoritmo de NTM. Normalmente, el ajuste de valores bajos `mini_batch_size` y pequeños `learning_rate` da como resultado pérdidas de validación inferiores, aunque puede tardarse más en capacitar. Las pérdidas de validación bajas no producen necesariamente más temas coherentes interpretados por humanos. El efecto de otros hiperparámetros en capacitación y pérdida de validación puede oscilar entre un conjunto de datos y otro. Para ver qué valores son compatibles, consulte [Hiperparámetros de NTM](ntm_hyperparameters.md).
| Nombre del parámetro | Tipo de parámetro | Intervalos recomendados |
| --- | --- | --- |
| encoder\$1layers\$1activation | CategoricalParameterRanges | ["sigmoid", "tanh", "relu"] |
| learning\$1rate | ContinuousParameterRange | MinValue: 1e-4,: 0.1 MaxValue |
| mini\$1batch\$1size | IntegerParameterRanges | MinValue: 16,: 2048 MaxValue |
| optimizer | CategoricalParameterRanges | ["sgd", "adam", "adadelta"] |
| rescale\$1gradient | ContinuousParameterRange | MinValue: 0,1, 1,0 MaxValue |
| weight\$1decay | ContinuousParameterRange | MinValue: 0,0, MaxValue 1,0 |
# Formatos de respuesta de NTM
Todos los algoritmos integrados de Amazon SageMaker AI siguen el formato de inferencia de entrada común descrito en [Formatos de datos comunes: inferencia](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html). Este tema contiene una lista de los formatos de salida disponibles para el algoritmo NTM de SageMaker IA.
## Formato de respuesta JSON
```
{
"predictions": [
{"topic_weights": [0.02, 0.1, 0,...]},
{"topic_weights": [0.25, 0.067, 0,...]}
]
}
```
## Formato de respuesta JSONLINES
```
{"topic_weights": [0.02, 0.1, 0,...]}
{"topic_weights": [0.25, 0.067, 0,...]}
```
## Formato de respuesta 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
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`.
# Sequence-to-Sequence Algoritmo
Amazon SageMaker AI Sequence to Sequence es un algoritmo de aprendizaje supervisado en el que la entrada es una secuencia de fichas (por ejemplo, texto o audio) y la salida generada es otra secuencia de fichas. Los ejemplos de aplicaciones incluyen: traducción automática (introducir una oración de un idioma y predecir cómo sería esa oración en otro idioma), resumen de texto (introducir una cadena de palabras más larga y predecir una cadena de palabras más corta que sea un resumen), speech-to-text (clips de audio convertidos en oraciones de salida en fichas). Recientemente, se han diseñado correctamente problemas en este dominio con redes neuronales profundas que muestran un importante aumento del rendimiento a través de las metodologías anteriores. Amazon SageMaker AI seq2seq utiliza modelos de redes neuronales recurrentes (RNNs) y redes neuronales convolucionales (CNN) con atención como arquitecturas de codificador-decodificador.
**Topics**
+ [Interfaz Sequence-to-Sequence de entrada/salida para el algoritmo](#s2s-inputoutput)
+ [Recomendación de instancia EC2 Sequence-to-Sequence para el algoritmo](#s2s-instances)
+ [Sequence-to-Sequence Cuadernos de muestra](#seq-2-seq-sample-notebooks)
+ [Cómo funciona Sequence-to-Sequence](seq-2-seq-howitworks.md)
+ [Sequence-to-Sequence Hiperparámetros](seq-2-seq-hyperparameters.md)
+ [Ajuste un Sequence-to-Sequence modelo](seq-2-seq-tuning.md)
## Interfaz Sequence-to-Sequence de entrada/salida para el algoritmo
**Entrenamiento**
SageMaker AI seq2seq espera datos en formato Recordio-ProtoBUF. Sin embargo, los tokens se esperan como enteros, no como puntos flotantes, como suele ser el caso.
Se incluye un script para convertir datos desde archivos de texto tokenizados al formato protobuf en [el bloc de notas de muestra de seq2seq](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html). Por lo general, empaqueta los datos en tensores de números enteros de 32 bits y genera los archivos de vocabulario necesarios que se precisan para la inferencia y el cálculo de métricas.
Una vez realizado el procesamiento previo, se puede invocar el algoritmo para la capacitación. El algoritmo espera tres canales:
+ `train`: debe contener los datos de capacitación (por ejemplo, el archivo `train.rec` generado por el script de preprocesamiento).
+ `validation`: debe contener los datos de validación (por ejemplo, el archivo `val.rec` generado por el script de preprocesamiento).
+ `vocab`: debe contener dos archivos de vocabulario (`vocab.src.json` y `vocab.trg.json`).
Si el algoritmo no encuentra datos en alguno de estos tres canales, se producirá un error en los resultados de capacitación.
**Inferencia**
Para los puntos de enlace alojados, la inferencia admite dos formatos de datos. Para realizar la inferencia mediante tokens de texto separados por espacios, utilice el formato `application/json`. De lo contrario, utilice el formato `recordio-protobuf` para trabajar con los datos codificados de números enteros. Ambos modos admiten la creación de lotes de datos de entrada. El formato `application/json` también le permite visualizar la matriz de atención.
+ `application/json`: espera la entrada en formato JSON y devuelve la salida en formato JSON. Ambos tipos de aceptación y contenido deben ser `application/json`. Se espera que las secuencias sean una cadena con tokens separados por espacios en blanco. Se recomienda este formato cuando el número de secuencias de origen en el lote es pequeño. También admite las siguientes opciones de configuración adicionales:
`configuration`: \$1`attention_matrix`: `true`\$1: devuelve la matriz de atención para una secuencia de entrada determinada.
+ `application/x-recordio-protobuf`: espera la entrada en formato `recordio-protobuf` y devuelve la salida en `recordio-protobuf format`. Ambos tipos de aceptación y contenido deben ser `applications/x-recordio-protobuf`. Para este formato, las secuencias de origen deben convertirse en una lista de números enteros para la codificación protobuf posterior. Este formato es el recomendado para la inferencia masiva.
Para la transformación por lotes, la interfaz admite el formato de líneas JSON. La transformación por lotes espera la entrada en formato de líneas JSON y devuelve la salida en formato de líneas JSON. Ambos tipos de aceptación y contenido deben ser `application/jsonlines`. El formato para la entrada es el siguiente:
```
content-type: application/jsonlines
{"source": "source_sequence_0"}
{"source": "source_sequence_1"}
```
El formato para la respuesta es el siguiente:
```
accept: application/jsonlines
{"target": "predicted_sequence_0"}
{"target": "predicted_sequence_1"}
```
Para obtener detalles adicionales sobre cómo serializar y deserializar las entradas y salidas en formatos específicos para la referencia, consulte [Sequence-to-Sequence Cuadernos de muestra](#seq-2-seq-sample-notebooks).
## Recomendación de instancia EC2 Sequence-to-Sequence para el algoritmo
El algoritmo seq2seq de Amazon SageMaker AI solo es compatible con los tipos de instancias de GPU y solo se puede entrenar en una sola máquina. Sin embargo, puede usar instancias con varias. GPUs El algoritmo seq2seq es compatible con las familias de instancias de GPU P2, P3, G4dn y G5.
## Sequence-to-Sequence Cuadernos de muestra
Para ver un ejemplo de cuaderno que muestra cómo usar el algoritmo SageMaker AI Sequence to Sequence para entrenar un modelo de traducción inglés-alemán, consulte [Ejemplo de traducción automática inglés-alemán con SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/seq2seq_translation_en-de/SageMaker-Seq2Seq-Translation-English-German.html) AI Seq2Seq. Para obtener instrucciones sobre cómo crear instancias de Jupyter Notebook y acceder a ellas, que puede utilizar para ejecutar el ejemplo en IA, consulte. SageMaker [Instancias de Amazon SageMaker Notebook](nbi.md) Una vez que haya creado una instancia de bloc de notas y la haya abierto, seleccione la pestaña **Ejemplos de SageMaker IA** para ver una lista de todos los ejemplos de SageMaker IA. Los blocs de notas de modelado de ejemplos que utilizan los algoritmos NTM se encuentran en la sección de **introducción a algoritmos de Amazon**. Para abrir un cuaderno, haga clic en la pestaña **Usar** y seleccione **Crear copia**.
# Cómo funciona Sequence-to-Sequence
Por lo general, una red neuronal para el sequence-to-sequence modelado consta de varias capas, que incluyen:
+ Una **capa de integración**. En esta capa, la matriz de entrada, que son tokens de entrada codificados de forma dispersa (por ejemplo, con codificación en caliente) se mapean en una capa de características densa. Esto es necesario porque un vector de características de alta dimensión es más capaz de codificar la información relativa a un elemento concreto (palabra que significa corpus de texto) que un vector simple one-hot-encoded. También es una práctica habitual inicializar esta capa de incrustación con un vector de palabras previamente entrenado, como [Glove](https://nlp.stanford.edu/projects/glove/), [FastText](https://fasttext.cc/)o inicializarlo aleatoriamente y aprender los parámetros durante el entrenamiento.
+ Una **capa del codificador**. Después de que los tokens de entrada se mapeen en un espacio de características de grandes dimensiones, la secuencia pasa por una capa del codificador para comprimir toda la información desde la capa de integración de entrada (o toda la secuencia) en un vector de características de longitud fija. Normalmente, un codificador se compone de redes de tipo RNN como de memoria a corto y largo plazo (LSTM) o unidades recurrentes cerradas (GRU). (el [blog de Colah](http://colah.github.io/posts/2015-08-Understanding-LSTMs/) explica la LSTM con más detalles).
+ Una **capa de decodificador**. La capa de decodificador toma este vector de características codificado y produce la secuencia de salida de tokens. Esta capa también se crea normalmente con arquitecturas RNN (LSTM y GRU).
Se realiza la capacitación de todo el modelo conjuntamente para maximizar la probabilidad de la secuencia de destino una vez proporcionada la secuencia de origen. Sutskever et al. introdujo [este modelo por primera vez](https://papers.nips.cc/paper/5346-sequence-to-sequence-learning-with-neural-networks.pdf) en 2014.
**Mecanismo de atención**. La desventaja de un marco de trabajo de codificador-decodificador es que el desempeño del modelo desciende a medida que la longitud de la secuencia de origen aumenta debido al límite de cantidad de información que puede contener el vector de características cifrado de longitud fija. Para resolver este problema, en 2015, Bahdanau et al. propuso el [mecanismo de atención](https://arxiv.org/pdf/1409.0473.pdf). En un mecanismo de atención, el decodificador intenta buscar la ubicación de la secuencia del codificador en la que podría ubicarse la información más importante y utiliza esa información y las palabras decodificadas anteriormente para predecir el siguiente token en la secuencia.
Para obtener más detalles, consulte el documento técnico de [enfoques eficaces de traducción automática neuronal basada en atención](https://arxiv.org/abs/1508.04025) de Luong, et al. que explica y simplifica los cálculos para diversos mecanismos de atención. Además, el documento técnico de [sistema de traducción automática neuronal de Google: reducir la brecha entre la traducción humana y automática](https://arxiv.org/abs/1609.08144) de Wu, et al. describe la arquitectura de Google para la traducción automática, que usa conexiones de omisión entre las capas de codificador y decodificador.
# Sequence-to-Sequence Hiperparámetros
En la siguiente tabla se enumeran los hiperparámetros que puede configurar al entrenar con el algoritmo Amazon SageMaker AI Sequence-to-Sequence (seq2seq).
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| batch\$1size | Tamaño del minilote para el gradiente descendiente. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 64 |
| beam\$1size | Longitud del haz para la búsqueda de haces. Se utiliza durante la capacitación de la computación `bleu` y se utiliza durante la inferencia. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 5 |
| bleu\$1sample\$1size | Número de instancias que elegir desde el conjunto de datos de validación para decodificar y calcular la puntuación `bleu` durante la capacitación. Establézcala en -1 para utilizar el conjunto de validación completo (si se elige `bleu` como `optimized_metric`). **Opcional** Valores válidos: número entero Valor predeterminado: 0 |
| bucket\$1width | Devuelve buckets (origen, destino) hasta (`max_seq_len_source`, `max_seq_len_target`). El lado más largo de los datos usa pasos de, `bucket_width` mientras que el lado más corto usa pasos reducidos según la relación de longitud promedio. target/source Si uno de los lados alcanza la longitud máxima antes que el otro, el ancho de los buckets adicionales de ese lado se fija a ese lado de `max_len`. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 10 |
| bucketing\$1enabled | Establézcalo en `false` para deshabilitar la creación de buckets y expandirlos con la longitud máxima. **Opcional** Valores válidos: `true` o `false` Valor predeterminado: `true` |
| checkpoint\$1frequency\$1num\$1batches | Punto de comprobación y evaluación cada x lotes. Este hiperparámetro de puntos de control se pasa al algoritmo seq2seq de la SageMaker IA para detenerlo anticipadamente y recuperar el mejor modelo. Los puntos de control del algoritmo se ejecutan localmente en el contenedor de entrenamiento del algoritmo y no son compatibles con los puntos de control de la IA. SageMaker El algoritmo guarda temporalmente los puntos de control en una ruta local y guarda el mejor artefacto del modelo en la ruta de salida del modelo en S3 una vez finalizado el trabajo de entrenamiento. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 1000 |
| checkpoint\$1threshold | Se permite que el número máximo de modelo de puntos de comprobación no mejore en `optimized_metric` en el conjunto de datos de validación antes de que se detenga la capacitación. Este hiperparámetro de puntos de control se transfiere al algoritmo seq2seq de la SageMaker IA para detenerlo anticipadamente y recuperar el mejor modelo. Los puntos de control del algoritmo se ejecutan localmente en el contenedor de entrenamiento del algoritmo y no son compatibles con los puntos de control de la IA. SageMaker El algoritmo guarda temporalmente los puntos de control en una ruta local y guarda el mejor artefacto del modelo en la ruta de salida del modelo en S3 una vez finalizado el trabajo de entrenamiento. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 3 |
| clip\$1gradient | Los valores de gradiente absolutos de clips son superiores a este. Establézcalo en negativo para deshabilitar. **Opcional** Valores válidos: número flotante Valor predeterminado: 1 |
| cnn\$1activation\$1type | El tipo de activación `cnn` que se va a utilizar. **Opcional** Valores válidos: Cadena. Puede ser uno de los siguientes: `glu`, `relu`, `softrelu`, `sigmoid` o bien `tanh`. Valor predeterminado: `glu` |
| cnn\$1hidden\$1dropout | Probabilidad de abandono para al abandono entre capas convolucionales. **Opcional** Valores válidos: número flotante. Rango en [0,1]. Valor predeterminado: 0 |
| cnn\$1kernel\$1width\$1decoder | Ancho de kernel para el decodificador `cnn`. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 5 |
| cnn\$1kernel\$1width\$1encoder | Ancho de kernel para el codificador `cnn`. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 3 |
| cnn\$1num\$1hidden | Número de unidades ocultas `cnn` para el codificador y decodificador. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 512 |
| decoder\$1type | Tipo de decodificador. **Opcional** Valores válidos: Cadena. `rnn` o `cnn`. Valor predeterminado: *rnn* |
| embed\$1dropout\$1source | Probabilidad de abandono para las incrustaciones del lado del origen. **Opcional** Valores válidos: número flotante. Rango en [0,1]. Valor predeterminado: 0 |
| embed\$1dropout\$1target | Probabilidad de abandono para las incrustaciones del lado del destino. **Opcional** Valores válidos: número flotante. Rango en [0,1]. Valor predeterminado: 0 |
| encoder\$1type | Tipo de codificador. La arquitectura `rnn` se basa en el mecanismo de atención de Bahdanau et al. y la arquitectura *cnn* se basa en Gehring et al. **Opcional** Valores válidos: Cadena. `rnn` o `cnn`. Valor predeterminado: `rnn` |
| fixed\$1rate\$1lr\$1half\$1life | Vida media de la tasa de aprendizaje en términos de número de puntos de comprobación para programadores `fixed_rate_`\$1. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 10 |
| learning\$1rate | Tasa de aprendizaje inicial. **Opcional** Valores válidos: número flotante Valor predeterminado: 0.0003 |
| loss\$1type | Función de pérdida para la capacitación. **Opcional** Valores válidos: Cadena. `cross-entropy` Valor predeterminado: `cross-entropy` |
| lr\$1scheduler\$1type | El tipo de programador de la tasa de aprendizaje. `plateau_reduce` conlleva la reducción de la tasa de aprendizaje cuando `optimized_metric` está con `validation_accuracy` detenido. `inv_t` es la decadencia de tiempo inversa. `learning_rate`/(1\$1`decay_rate`\$1t) **Opcional** Valores válidos: Cadena. Uno de los valores de entre `plateau_reduce`, `fixed_rate_inv_t` o `fixed_rate_inv_sqrt_t`. Valor predeterminado: `plateau_reduce` |
| max\$1num\$1batches | Número máximo de por updates/batches procesar. -1 para infinito. **Opcional** Valores válidos: número entero Valor predeterminado: -1 |
| max\$1num\$1epochs | Número máximo de fechas de inicio por los que pasan los datos de capacitación antes de que se detenga la adaptación. La capacitación continúa hasta este número de fechas de inicio incluso si la precisión de la validación no mejora si se aprueba el parámetro. Se ignora si no se aprueba. **Opcional** Valores válidos: entero positivo y menor o igual que max\$1num\$1epochs. Valor predeterminado: ninguno |
| max\$1seq\$1len\$1source | La longitud máxima para la longitud de secuencia de origen. Las secuencias que superen esta longitud se truncarán con esa longitud. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 100 |
| max\$1seq\$1len\$1target | La longitud máxima para la longitud de secuencia de destino. Las secuencias que superen esta longitud se truncarán con esa longitud. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 100 |
| min\$1num\$1epochs | Número mínimo de fechas de inicio que la capacitación debe ejecutar antes de que se detenga a través de las condiciones `early_stopping`. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 0 |
| momentum | Constante de momento utilizada para `sgd`. No apruebe este parámetro si está usando `adam` o `rmsprop`. **Opcional** Valores válidos: número flotante Valor predeterminado: ninguno |
| num\$1embed\$1source | Tamaño de integración para tokens de origen. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 512 |
| num\$1embed\$1target | Tamaño de integración para tokens de destino. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 512 |
| num\$1layers\$1decoder | Número de capas para el decodificador *rnn* o *cnn*. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 1 |
| num\$1layers\$1encoder | Número de capas para el codificador `rnn` o `cnn`. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 1 |
| optimized\$1metric | Métricas que optimizar con una detención temprana. **Opcional** Valores válidos: Cadena. Uno de los valores de entre `perplexity`, `accuracy` o `bleu`. Valor predeterminado: `perplexity` |
| optimizer\$1type | Optimizador de entre el que elegir. **Opcional** Valores válidos: Cadena. Uno de los valores de entre `adam`, `sgd` o `rmsprop`. Valor predeterminado: `adam` |
| plateau\$1reduce\$1lr\$1factor | Factor con el que multiplicar la tasa de aprendizaje (para `plateau_reduce`). **Opcional** Valores válidos: número flotante Valor predeterminado: 0,5 |
| plateau\$1reduce\$1lr\$1threshold | Para el programador `plateau_reduce`, multiplique la tasa de aprendizaje por el factor de reducción si `optimized_metric` no mejoró para estos puntos de comprobación distintos. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 3 |
| rnn\$1attention\$1in\$1upper\$1layers | Propague la atención a las capas superiores de *rnn*, como en el documento de Google NMT. Solo es aplicable si se utiliza más de una capa. **Opcional** Valores válidos: booleano (`true` o `false`) Valor predeterminado: `true` |
| rnn\$1attention\$1num\$1hidden | El valor predeterminado del número de unidades ocultas para capas de atención es `rnn_num_hidden`. **Opcional** Valores válidos: número entero positivo Valor predeterminado: `rnn_num_hidden` |
| rnn\$1attention\$1type | Modelo de atención para codificadores. `mlp` hace referencia a concat y bilineal hace referencia a general en el documento Luong et al. **Opcional** Valores válidos: Cadena. Puede ser uno de los siguientes: `dot`, `fixed`, `mlp` o bien `bilinear`. Valor predeterminado: `mlp` |
| rnn\$1cell\$1type | Tipo específico de arquitectura `rnn`. **Opcional** Valores válidos: Cadena. `lstm` o `gru`. Valor predeterminado: `lstm` |
| rnn\$1decoder\$1state\$1init | Cómo inicializar estados del decodificador `rnn` a partir de codificadores. **Opcional** Valores válidos: Cadena. Uno de los valores de entre `last`, `avg` o `zero`. Valor predeterminado: `last` |
| rnn\$1first\$1residual\$1layer | La primera capa *rnn* que tiene una conexión residual, solo aplicable si el número de capas del codificador o decodificador es superior a 1. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 2 |
| rnn\$1num\$1hidden | El número de unidades ocultas *rnn* para el codificador y el decodificador. Debe ser múltiplo de 2 porque el algoritmo utiliza la memoria a corto y largo plazo (LSTM) bidireccional de forma predeterminada. **Opcional** Valores válidos: número par entero positivo Valor predeterminado: 1024 |
| rnn\$1residual\$1connections | Agregue la conexión residual al *rnn* apilado. El número de capas debe ser superior a 1. **Opcional** Valores válidos: booleano (`true` o `false`) Valor predeterminado: `false` |
| rnn\$1decoder\$1hidden\$1dropout | La probabilidad de abandono para el estado oculto que combina el contexto con el estado oculto *rnn* en el decodificador. **Opcional** Valores válidos: número flotante. Rango en [0,1]. Valor predeterminado: 0 |
| training\$1metric | Las métricas para realizar un seguimiento de la capacitación en los datos de validación. **Opcional** Valores válidos: Cadena. `perplexity` o `accuracy`. Valor predeterminado: `perplexity` |
| weight\$1decay | Constante de decadencia de ponderación. **Opcional** Valores válidos: número flotante Valor predeterminado: 0 |
| weight\$1init\$1scale | Escala de la inicialización de la ponderación (para la inicialización `uniform` y `xavier`). **Opcional** Valores válidos: número flotante Valor predeterminado: 2.34 |
| weight\$1init\$1type | Tipo de inicialización de la ponderación. **Opcional** Valores válidos: Cadena. `uniform` o `xavier`. Valor predeterminado: `xavier` |
| xavier\$1factor\$1type | Tipo de factor de xavier. **Opcional** Valores válidos: Cadena. Uno de los valores de entre `in`, `out` o `avg`. Valor predeterminado: `in` |
# Ajuste un Sequence-to-Sequence modelo
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. Puede elegir la métrica objetiva de las métricas que el algoritmo computa. El ajuste de modelo automático busca los hiperparámetros elegidos para encontrar la combinación de valores que obtienen el modelo que optimiza la métrica objetiva.
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 Sequence-to-Sequence algoritmo
El algoritmo de secuencia a secuencia informa sobre tres métricas que se calculan durante la capacitación. Elija una de ellas como objetivo para optimizar al ajustar los valores de hiperparámetro.
| Nombre de métrica | Description (Descripción) | Dirección de optimización |
| --- | --- | --- |
| validation:accuracy | Precisión calculada en el conjunto de datos de validación. | Maximizar |
| validation:bleu | Puntuación [bleu](https://en.wikipedia.org/wiki/BLEU) calculada en el conjunto de datos de validación. Como la computación BLEU es cara, puede elegir computar BLEU en una submuestra aleatoria del conjunto de datos de validación para acelerar el proceso de capacitación general. Use el parámetro `bleu_sample_size` para especificar la submuestra. | Maximizar |
| validation:perplexity | [Perplejidad](https://en.wikipedia.org/wiki/Perplexity), es una función de pérdida computada en el conjunto de datos de validación. La perplejidad mide la entropía cruzada entre una muestra empírica y la distribución prevista por un modelo y de esta forma proporciona una medida de lo bien que un modelo predice los valores de muestra. Los modelos que son buenos prediciendo una muestra tienen una perplejidad baja. | Minimizar |
## Hiperparámetros ajustables Sequence-to-Sequence
Puede ajustar los siguientes hiperparámetros para el algoritmo SageMaker AI Sequence to Sequence. Los hiperparámetros que mayor impacto tienen en las métricas objetivas de secuencia a secuencia: `batch_size`, `optimizer_type`, `learning_rate`, `num_layers_encoder` y `num_layers_decoder`.
| Nombre del 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 el tipo xavier, escriba MinValue: 2.0, MaxValue: 3.0 Para el tipo uniforme: MinValue: -1.0, MaxValue: 1.0 |
| learning\$1rate | ContinuousParameterRange | MinValue: 0,00005, 0,2 MaxValue |
| weight\$1decay | ContinuousParameterRange | MinValue: 0,0, 0,1 MaxValue |
| momentum | ContinuousParameterRange | MinValue: 0,5, MaxValue 0,9 |
| clip\$1gradient | ContinuousParameterRange | MinValue: 1,0, MaxValue 5,0 |
| rnn\$1num\$1hidden | CategoricalParameterRange | Aplicable solo a redes neuronales recurrentes (RNNs). [128,256,512,1024,2048] |
| cnn\$1num\$1hidden | CategoricalParameterRange | Aplicable solo a redes neuronales convolucionales ()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] |
# Clasificación de textos - TensorFlow
El algoritmo Amazon SageMaker AI Text Classification es un TensorFlow algoritmo de aprendizaje supervisado que admite el aprendizaje por transferencia con muchos modelos previamente entrenados desde el [TensorFlow Hub](https://tfhub.dev/). Utilice el aprendizaje por transferencia para ajustar uno de los modelos previamente entrenados disponibles en su propio conjunto de datos, aunque no haya una gran cantidad de datos de texto disponibles. El algoritmo de clasificación de texto toma una cadena de texto como entrada y genera una probabilidad para cada una de las etiquetas de clase. Los conjuntos de datos de entrenamiento deben estar en formato CSV. Esta página incluye información sobre las recomendaciones de instancias de Amazon EC2 y cuadernos de muestra para Text Classification -. TensorFlow
**Topics**
+ [Cómo utilizar el algoritmo de clasificación de texto mediante SageMaker IA TensorFlow](text-classification-tensorflow-how-to-use.md)
+ [Interfaz de entrada y salida para el TensorFlow algoritmo de clasificación de textos](text-classification-tensorflow-inputoutput.md)
+ [Recomendación de instancia de Amazon EC2 para el algoritmo de clasificación de textos TensorFlow](#text-classification-tensorflow-instances)
+ [Clasificación de textos: TensorFlow ejemplos de cuadernos](#text-classification-tensorflow-sample-notebooks)
+ [Cómo TensorFlow funciona la clasificación de textos](text-classification-tensorflow-HowItWorks.md)
+ [TensorFlow Modelos Hub](text-classification-tensorflow-Models.md)
+ [Clasificación de texto: TensorFlow hiperparámetros](text-classification-tensorflow-Hyperparameter.md)
+ [Ajuste un modelo de clasificación de texto TensorFlow](text-classification-tensorflow-tuning.md)
# Cómo utilizar el algoritmo de clasificación de texto mediante SageMaker IA TensorFlow
Puede utilizar la clasificación de texto, TensorFlow como un algoritmo integrado de Amazon SageMaker AI. En la siguiente sección, se describe cómo utilizar la clasificación de texto TensorFlow con el SDK de Python para SageMaker IA. Para obtener información sobre cómo utilizar la clasificación de texto, TensorFlow desde la interfaz de usuario clásica de Amazon SageMaker Studio, consulte[SageMaker JumpStart modelos preentrenados](studio-jumpstart.md).
El TensorFlow algoritmo de clasificación de texto admite el aprendizaje por transferencia mediante cualquiera de los TensorFlow modelos preentrenados compatibles. Para obtener una lista de todos los modelos prentrenados disponibles, consulte [TensorFlow Modelos Hub](text-classification-tensorflow-Models.md). Cada modelo prentrenado tiene un `model_id` de modelo único. El siguiente ejemplo emplea BERT Base Uncased (`model_id`: `tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2`) para ajustar un conjunto de datos personalizado. Todos los modelos previamente entrenados se descargan previamente del TensorFlow Hub y se almacenan en buckets de Amazon S3 para que los trabajos de capacitación se puedan ejecutar de forma aislada en la red. Utilice estos artefactos de entrenamiento de modelos pregenerados para construir un estimador de IA. SageMaker
En primer lugar, recupere el URI de la imagen de Docker, del script de entrenamiento y del modelo prentrenado. Luego, cambie los hiperparámetros como crea conveniente. Puede ver un diccionario de Python con todos los hiperparámetros disponibles y sus valores predeterminados con `hyperparameters.retrieve_default`. Para obtener más información, consulte [Clasificación de texto: TensorFlow hiperparámetros](text-classification-tensorflow-Hyperparameter.md). Usa estos valores para construir un SageMaker estimador de IA.
**nota**
Los valores de hiperparámetros predeterminados son diferentes para los distintos modelos. Por ejemplo, para los modelos más grandes, el tamaño de lote predeterminado es menor.
En este ejemplo, se utiliza el conjunto de datos [https://www.tensorflow.org/datasets/catalog/glue#gluesst2](https://www.tensorflow.org/datasets/catalog/glue#gluesst2), que contiene reseñas positivas y negativas sobre películas. Hemos descargado previamente el conjunto de datos y hemos hecho que esté disponible en Amazon S3. Para ajustar su modelo, llame a `.fit` utilizando la ubicación de Amazon S3 del conjunto de datos de entrenamiento. Cualquier bucket de S3 utilizado en un bloc de notas debe estar en la misma AWS región que la instancia de portátil que accede a él.
```
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 obtener más información sobre cómo utilizar el TensorFlow algoritmo de clasificación de SageMaker textos para transferir el aprendizaje en un conjunto de datos personalizado, consulte el cuaderno [Introducción a JumpStart la clasificación de textos](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).
# Interfaz de entrada y salida para el TensorFlow algoritmo de clasificación de textos
Cada uno de los modelos previamente entrenados que figuran en TensorFlow Hub Models se puede ajustar a cualquier conjunto de datos compuesto por oraciones de texto con cualquier número de clases. El modelo prentrenado asocia una capa de clasificación al modelo de incrustación de texto e inicia los parámetros de la capa en valores aleatorios. La dimensión de salida de la capa de clasificación se determina en función del número de clases detectadas en los datos de entrada.
Ten cuidado con el formato de los datos de entrenamiento para introducirlos en el modelo de clasificación de textos. TensorFlow
+ **Formato de entrada de los datos de entrenamiento:** un directorio con un archivo `data.csv`. Cada fila de la primera columna debe tener etiquetas de clase entera entre 0 y el número de clases. Cada fila de la segunda columna debe tener los datos de texto correspondientes.
Lo que sigue es un ejemplo de una entrada de archivo CSV: Tenga en cuenta que el archivo no debería tener ningún encabezado. El archivo debe alojarse en un bucket de Amazon S3 con una ruta similar a `s3://bucket_name/input_directory/`. Tenga en cuenta que es obligatorio incluir `/` al final.
```
| | |
|---|---|
|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|
|...|...|
```
## Entrenamiento incremental
Puedes iniciar el entrenamiento de un nuevo modelo con artefactos de un modelo que hayas entrenado previamente con SageMaker IA. El entrenamiento incremental supone un ahorro de tiempo cuando queremos entrenar un nuevo modelo con datos idénticos o similares.
**nota**
Solo puedes sembrar un modelo de clasificación de texto basado en SageMaker IA (un TensorFlow modelo con otro de clasificación de textos) TensorFlow entrenado en SageMaker IA.
Para el entrenamiento incremental, puede utilizar cualquier conjunto de datos, siempre y cuando el conjunto de clases siga siendo el mismo. El paso de entrenamiento incremental es similar al paso de ajuste; la diferencia es que, en lugar de comenzar con un modelo previamente entrenado, se comienza con un modelo de ajuste fino existente.
Para obtener más información sobre el uso del entrenamiento incremental con el TensorFlow algoritmo de clasificación de textos mediante SageMaker IA, consulte el cuaderno de muestra [Introducción a JumpStart la clasificación de textos](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).
## Inferencia con el algoritmo de clasificación de textos TensorFlow
Puede alojar el modelo ajustado que resulta de su formación en clasificación de TensorFlow textos para la inferencia. Para la inferencia, todos los formatos de texto sin procesar deben ser del tipo de contenido `application/x-text`.
Al ejecutar la inferencia, se obtienen valores de probabilidad, etiquetas de clase para todas las clases y la etiqueta pronosticada correspondiente al índice de clase con la probabilidad más alta, codificada en formato JSON. El TensorFlow modelo de clasificación de texto procesa una sola cadena por solicitud y genera solo una línea. Lo siguiente es un ejemplo de una respuesta en formato JSON:
```
accept: application/json;verbose
{"probabilities": [prob_0, prob_1, prob_2, ...],
"labels": [label_0, label_1, label_2, ...],
"predicted_label": predicted_label}
```
Si `accept` se establece en `application/json`, el modelo solo genera probabilidades.
## Recomendación de instancia de Amazon EC2 para el algoritmo de clasificación de textos TensorFlow
El TensorFlow algoritmo de clasificación de texto es compatible con todas las instancias de CPU y GPU para el entrenamiento, incluidas las siguientes:
+ `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`
Para el entrenamiento con lotes grandes, recomendamos utilizar instancias de GPU con más memoria. Para la inferencia, se pueden usar instancias de CPU (como M5) o de GPU (P2, P3, G4dn o G5). Para obtener una lista completa de instancias de SageMaker formación e inferencia en todas AWS las regiones, consulta [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
## Clasificación de textos: TensorFlow ejemplos de cuadernos
Para obtener más información sobre cómo utilizar el TensorFlow algoritmo de clasificación de texto de SageMaker IA para el aprendizaje por transferencia en un conjunto de datos personalizado, consulte la [introducción al JumpStart cuaderno de clasificación de textos](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart_text_classification/Amazon_JumpStart_Text_Classification.ipynb).
Para obtener instrucciones sobre cómo crear instancias del cuaderno de Jupyter y acceder a ellas, que puede utilizar para ejecutar el ejemplo en SageMaker IA, consulte. [Instancias de Amazon SageMaker Notebook](nbi.md) Una vez que haya creado una instancia de bloc de notas y la haya abierto, seleccione la pestaña **Ejemplos de SageMaker IA** para ver una lista de todos los ejemplos de SageMaker IA. Para abrir un cuaderno, elija su pestaña **Usar** y elija **Crear copia**.
# Cómo TensorFlow funciona la clasificación de textos
El TensorFlow algoritmo de clasificación de texto toma el texto tal como lo clasifica en una de las etiquetas de clase de salida. Las redes de aprendizaje profundo, como [BERT](https://arxiv.org/pdf/1810.04805.pdf), son muy precisas a la hora de clasificar textos. También hay redes de aprendizaje profundo que se entrenan con conjuntos de datos de texto de gran tamaño, por ejemplo TextNet, que tiene más de 11 millones de textos repartidos en unas 11 000 categorías. Después de entrenar una red con TextNet datos, puede ajustarla en un conjunto de datos con un enfoque particular para realizar tareas de clasificación de textos más específicas. El TensorFlow algoritmo de clasificación de textos de Amazon SageMaker AI admite el aprendizaje por transferencia en muchos modelos previamente entrenados que están disponibles en el TensorFlow Hub.
Según el número de etiquetas de clase que contengan tus datos de entrenamiento, se adjunta una capa de clasificación de texto al TensorFlow modelo previamente entrenado que elijas. La capa de clasificación está compuesta por una capa de eliminación, una capa densa y una capa totalmente conectada con regularización L2, y se inicia con ponderaciones aleatorias. Puede cambiar los valores de los hiperparámetros de la tasa de eliminación (en la capa de eliminación) y el factor de regularización L2 (en la capa densa).
Puede ajustar toda la red (lo que incluye el modelo prentrenado) o solo la capa de clasificación superior en los nuevos datos de entrenamiento. Con este método de aprendizaje por transferencia, es posible llevar a cabo el entrenamiento con conjuntos de datos más pequeños.
# TensorFlow Modelos Hub
Los siguientes modelos previamente entrenados están disponibles para su uso en el aprendizaje por transferencia con el TensorFlow algoritmo de clasificación de textos.
El tamaño, la cantidad de parámetros, el tiempo de entrenamiento y la latencia de inferencia de estos modelos puede variar considerablemente para un conjunto de datos determinado. El mejor modelo para su caso de uso dependerá de la complejidad del conjunto de datos de ajuste y de sus necesidades con respecto al tiempo de entrenamiento, la latencia de inferencia o la precisión del modelo.
| Nombre del modelo | `model_id` | origen |
| --- | --- | --- |
| BERT Base Uncased | `tensorflow-tc-bert-en-uncased-L-12-H-768-A-12-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/bert_en_uncased_L-12_H-768_A-12/3) |
| BERT Base Cased | `tensorflow-tc-bert-en-cased-L-12-H-768-A-12-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/bert_en_cased_L-12_H-768_A-12/3) |
| BERT Base Multilingual Cased | `tensorflow-tc-bert-multi-cased-L-12-H-768-A-12-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/bert_multi_cased_L-12_H-768_A-12/3) |
| Small BERT L-2\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-128-A-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-128_A-2/1) |
| Small BERT L-2\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-256-A-4` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-256_A-4/1) |
| Small BERT L-2\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-512-A-8` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-512_A-8/1) |
| Small BERT L-2\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-2-H-768-A-12` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-2_H-768_A-12/1) |
| Small BERT L-4\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-128-A-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-128_A-2/1) |
| Small BERT L-4\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-256-A-4` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-256_A-4/1) |
| Small BERT L-4\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-512-A-8` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1) |
| Small BERT L-4\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-4-H-768-A-12` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-768_A-12/1) |
| Small BERT L-6\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-128-A-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-128_A-2/1) |
| Small BERT L-6\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-256-A-4` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-256_A-4/1) |
| Small BERT L-6\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-512-A-8` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-512_A-8/1) |
| Small BERT L-6\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-6-H-768-A-12` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-6_H-768_A-12/1) |
| Small BERT L-8\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-128-A-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-128_A-2/1) |
| Small BERT L-8\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-256-A-4` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-256_A-4/1) |
| Small BERT L-8\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-512-A-8` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-512_A-8/1) |
| Small BERT L-8\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-8-H-768-A-12` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-8_H-768_A-12/1) |
| Small BERT L-10\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-128-A-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-128_A-2/1) |
| Small BERT L-10\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-256-A-4` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-256_A-4/1) |
| Small BERT L-10\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-512-A-8` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-512_A-8/1) |
| Small BERT L-10\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-10-H-768-A-12` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-10_H-768_A-12/1) |
| Small BERT L-12\$1H-128\$1A-2 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-128-A-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-128_A-2/1) |
| Small BERT L-12\$1H-256\$1A-4 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-256-A-4` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-256_A-4/1) |
| Small BERT L-12\$1H-512\$1A-8 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-512-A-8` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-512_A-8/1) |
| Small BERT L-12\$1H-768\$1A-12 | `tensorflow-tc-small-bert-bert-en-uncased-L-12-H-768-A-12` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-12_H-768_A-12/1) |
| BERT Large Uncased | `tensorflow-tc-bert-en-uncased-L-24-H-1024-A-16-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/bert_en_uncased_L-24_H-1024_A-16/3) |
| BERT Large Cased | `tensorflow-tc-bert-en-cased-L-24-H-1024-A-16-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/bert_en_cased_L-24_H-1024_A-16/3) |
| BERT Large Uncased Whole Word Masking | `tensorflow-tc-bert-en-wwm-uncased-L-24-H-1024-A-16-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/bert_en_wwm_uncased_L-24_H-1024_A-16/3) |
| BERT Large Cased Whole Word Masking | `tensorflow-tc-bert-en-wwm-cased-L-24-H-1024-A-16-2` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/bert_en_wwm_cased_L-24_H-1024_A-16/3) |
| ALBERT Base | `tensorflow-tc-albert-en-base` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/albert_en_base/2) |
| ELECTRA Small\$1\$1 | `tensorflow-tc-electra-small-1` | [TensorFlow Enlace al hub](https://tfhub.dev/google/electra_small/2) |
| ELECTRA Base | `tensorflow-tc-electra-base-1` | [TensorFlow Enlace al hub](https://tfhub.dev/google/electra_base/2) |
| BERT Base Wikipedia y BooksCorpus | `tensorflow-tc-experts-bert-wiki-books-1` | [TensorFlow Enlace al hub](https://tfhub.dev/google/experts/bert/wiki_books/2) |
| BERT BASE MEDLINE/ PubMed | `tensorflow-tc-experts-bert-pubmed-1` | [TensorFlow Enlace hub](https://tfhub.dev/google/experts/bert/pubmed/2) |
| Talking Heads Base | `tensorflow-tc-talking-heads-base` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_base/1) |
| Talking Heads Large | `tensorflow-tc-talking-heads-large` | [TensorFlow Enlace al hub](https://tfhub.dev/tensorflow/talkheads_ggelu_bert_en_large/1) |
# Clasificación de texto: TensorFlow hiperparámetros
Los hiperparámetros son parámetros que se establecen antes de que un modelo de machine learning comience a aprender. Los siguientes hiperparámetros son compatibles con el TensorFlow algoritmo integrado de detección de objetos de Amazon SageMaker AI. Para obtener más información sobre el ajuste de hiperparámetros, consulte [Ajuste un modelo de clasificación de texto TensorFlow](text-classification-tensorflow-tuning.md).
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| batch\$1size | El tamaño del lote para la capacitación. Para el entrenamiento en instancias con múltiples GPUs, este tamaño de lote se usa en todas las GPUs. Valores válidos: número entero positivo. Valor predeterminado: `32`. |
| beta\$11 | El beta1 para los optimizadores `"adam"` y `"adamw"`. Representa la tasa de degradación exponencial para las estimaciones del primer momento. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.9`. |
| beta\$12 | El beta2 para los optimizadores `"adam"` y `"adamw"`. Representa la tasa de degradación exponencial para las estimaciones del segundo momento. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.999`. |
| dropout\$1rate | La tasa de eliminación en la capa de eliminación, dentro de la capa de clasificación superior. Solo se usa cuando `reinitialize_top_layer` está establecido en `"True"`. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.2` |
| early\$1stopping | Se establece en `"True"` a fin de usar una lógica de detención temprana durante el entrenamiento. Si es `"False"`, no se utiliza la interrupción temprana. Valores válidos: cadena (`"True"` o `"False"`). Valor predeterminado: `"False"`. |
| early\$1stopping\$1min\$1delta | El cambio mínimo necesario para considerarse una mejora. Un cambio absoluto inferior al valor de early\$1stopping\$1min\$1delta no se considera mejora. Solo se usa cuando early\$1stopping está establecido en "True".Valores válidos: flotante, con el rango [`0.0`, `1.0`].Valor predeterminado: `0.0`. |
| early\$1stopping\$1patience | El número de epochs (fechas de inicio) para seguir entrenando sin que haya mejoras. Solo se usa cuando `early_stopping` está establecido en `"True"`. Valores válidos: número entero positivo. Valor predeterminado: `5`. |
| epochs | El número de fechas de inicio de capacitación. Valores válidos: número entero positivo. Valor predeterminado: `10`. |
| epsilon | El valor épsilon para los optimizadores `"adam"`, `"rmsprop"`, `"adadelta"` y `"adagrad"`. Se suele establecer en un valor pequeño para evitar la división por 0. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `1e-7`. |
| initial\$1accumulator\$1value | El valor inicial de los acumuladores o los valores de impulso por parámetro del optimizador `"adagrad"`. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.0001`. |
| learning\$1rate | La tasa de aprendizaje del optimizador. Valores válidos: flotante, con el rango [`0.0`, `1.0`].Valor predeterminado: `0.001`. |
| momentum | El valor de impulso para los optimizadores `"sgd"` y `"nesterov"`. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.9`. |
| optimizer | El tipo de optimizador. Para obtener más información, consulte [Optimizadores](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers) en la TensorFlow documentación. Valores válidos: cadena, `"adamw"`, `"adam"`, `"sgd"`, `"nesterov"`, `"rmsprop"`, ` "adagrad"` o `"adadelta"`. Valor predeterminado: `"adam"`. |
| regularizers\$1l2 | El factor de regularización L2 de la capa densa en la capa de clasificación. Solo se usa cuando `reinitialize_top_layer` está establecido en `"True"`. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.0001`. |
| reinitialize\$1top\$1layer | Si se establece en `"Auto"`, los parámetros de la capa de clasificación superior se reinicializan durante el ajuste. Para el entrenamiento incremental, los parámetros de la capa de clasificación superior no se reinicializan, a no ser que se establezca en `"True"`. Valores válidos: cadena, `"Auto"`, `"True"` o `"False"`. Valor predeterminado: `"Auto"`. |
| rho | El factor de descuento para el gradiente de los optimizadores `"adadelta"` y `"rmsprop"`. No se tiene en cuenta para otros optimizadores. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.95`. |
| train\$1only\$1on\$1top\$1layer | Si es `"True"`, solo se refinan los parámetros de la capa de clasificación superior. Si es `"False"`, todos los parámetros del modelo se refinan. Valores válidos: cadena (`"True"` o `"False"`). Valor predeterminado: `"False"`. |
| validation\$1split\$1ratio | La fracción de datos de entrenamiento que se va a dividir aleatoriamente para crear datos de validación. Solo se usa si no se suministran datos de validación a través del canal `validation`. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.2`. |
| warmup\$1steps\$1fraction | La fracción del número total de pasos de actualización del gradiente; la tasa de aprendizaje aumenta desde 0 hasta la tasa de aprendizaje inicial durante la fase de preparación. Solo se usa con el optimizador `adamw`. Valores válidos: flotante, con el rango [`0.0`, `1.0`]. Valor predeterminado: `0.1`. |
# Ajuste un modelo de clasificación de texto TensorFlow
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. Puede elegir la métrica objetiva de las métricas que el algoritmo computa. El ajuste de modelo automático busca los hiperparámetros elegidos para encontrar la combinación de valores que obtienen el modelo que optimiza la métrica objetiva.
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 mediante el algoritmo de clasificación de textos TensorFlow
Consulte la siguiente tabla para ver qué métricas calcula el TensorFlow algoritmo de clasificación de texto:.
| Nombre de métrica | Description (Descripción) | Dirección de optimización | Patrón de expresiones regulares |
| --- | --- | --- | --- |
| validation:accuracy | La ratio del número de predicciones correctas con respecto al número total de predicciones realizadas. | Maximizar | `val_accuracy=([0-9\\.]+)` |
## Clasificación de texto ajustable: hiperparámetros TensorFlow
Puede ajustar un modelo de clasificación de texto con los siguientes hiperparámetros. Los hiperparámetros con un mayor impacto en las métricas de objetivos de clasificación de texto son `batch_size`, `learning_rate` y `optimizer`. Ajuste los hiperparámetros relacionados con el optimizador, como `momentum`, `regularizers_l2`, `beta_1`, `beta_2` y `eps`, en función del `optimizer` seleccionado. Por ejemplo, utilice `beta_1` y `beta_2` solo cuando el `optimizer` sea `adamw` o `adam`.
Para obtener más información sobre los hiperparámetros que se utilizan en cada `optimizer`, consulte [Clasificación de texto: TensorFlow hiperparámetros](text-classification-tensorflow-Hyperparameter.md).
| Nombre del parámetro | Tipo de parámetro | Intervalos recomendados |
| --- | --- | --- |
| batch\$1size | IntegerParameterRanges | MinValue: 4, MaxValue: 128 |
| beta\$11 | ContinuousParameterRanges | MinValue: 1e-6, 0,999 MaxValue |
| beta\$12 | ContinuousParameterRanges | MinValue: 1e-6, 0,999 MaxValue |
| eps | ContinuousParameterRanges | MinValue: 1e-8,: 1,0 MaxValue |
| learning\$1rate | ContinuousParameterRanges | MinValue: 1e-6,: 0,5 MaxValue |
| momentum | ContinuousParameterRanges | MinValue: 0,0, 0,999 MaxValue |
| optimizer | CategoricalParameterRanges | ['adamw', 'adam', 'sgd', 'rmsprop', 'nesterov', 'adagrad', 'adadelta'] |
| regularizers\$1l2 | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,999 |
| train\$1only\$1on\$1top\$1layer | CategoricalParameterRanges | ['True', 'False'] |