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 integrados de SageMaker AI para datos tabulares
Amazon SageMaker AI proporciona algoritmos integrados y adaptados para el análisis de datos tabulares. Los datos tabulares son conjuntos de datos organizados en tablas compuestas por filas (observaciones) y columnas (características). Los algoritmos integrados de SageMaker AI para datos tabulares se pueden utilizar en problemas de clasificación o regresión.
+ [AutoGluon-Tabular](autogluon-tabular.md): un marco AutoML de código abierto que funciona ensamblando modelos y apilándolos en varias capas.
+ [CatBoost](catboost.md): una implementación del algoritmo de árboles potenciados por gradientes, con una potenciación ordenada y un algoritmo innovador para procesar características categóricas.
+ [Algoritmo de máquinas de factorización](fact-machines.md): una extensión de un modelo lineal que se ha diseñado para capturar de manera económica las interacciones entre características dentro de conjuntos de datos dispersos y de grandes dimensiones.
+ [Algoritmo k vecinos más próximos (k-NN) (K-Nearest Neighbors)](k-nearest-neighbors.md): un método no paramétrico que utiliza los k puntos etiquetados más cercanos para asignarle una etiqueta a un nuevo punto de datos (para la clasificación), o un valor objetivo previsto a partir de la media de los k puntos más cercanos (para la regresión).
+ [LightGBM](lightgbm.md): una implementación del algoritmo de árboles potenciados por gradiente que añade dos técnicas novedosas para mejorar la eficiencia y la escalabilidad; el muestreo unilateral basado en gradientes (GOSS) y la agrupación de características exclusivas (EFB).
+ [Algoritmo de aprendizaje lineal](linear-learner.md): aprende una función lineal para la regresión o una función de umbral lineal para la clasificación.
+ [TabTransformer](tabtransformer.md): una novedosa arquitectura de modelado de datos tabulares profundos basada en transformadores con atención automática.
+ [XGBoost algoritmo con Amazon SageMaker AI](xgboost.md): una implementación del algoritmo de árboles con potenciación por gradiente que combina un conjunto de estimaciones a partir de un conjunto de modelos más simples y débiles.
| Nombre de algoritmo | Nombre de canal | Modo de entrada de capacitación | Tipo de archivo | Clase de instancia | Paralelizable |
| --- | --- | --- | --- | --- | --- |
| AutoGluon-Tabular | Entrenamiento y validación (opcional) | Archivos | CSV | CPU o GPU (solo instancia única) | No |
| CatBoost | entrenamiento y validación (opcional) | Archivos | CSV | CPU (solo instancia única) | No |
| Máquinas de factorización | capacitación y prueba (opcional) | Archivo o canalización | recordIO-protobuf | CPU (GPU para datos densos) | Sí |
| K-Nearest-Neighbors (k-NN) | capacitación y prueba (opcional) | Archivo o canalización | recordIO-protobuf o CSV | CPU o GPU (dispositivo de GPU único en una o varias instancias) | Sí |
| LightGBM | entrenamiento y validación (opcional) | Archivos | CSV | CPU (solo instancia única) | No |
| Aprendiz lineal | capacitación y validación (opcional), prueba o ambos | Archivo o canalización | recordIO-protobuf o CSV | CPU o GPU | Sí |
| TabTransformer | entrenamiento y validación (opcional) | Archivos | CSV | CPU o GPU (solo instancia única) | No |
| XGBoost (0.90-1, 0.90-2, 1.0-1, 1.2-1, 1.2-21) | capacitación y validación (opcional) | Archivo o canalización | CSV, LibSVM o Parquet | CPU (o GPU para 1.2-1) | Sí |
# AutoGluon-Tabular
[AutoGluon-Tabular](https://auto.gluon.ai/stable/index.html) es un popular marco AutoML de código abierto que entrena modelos de aprendizaje automático de alta precisión en un conjunto de datos tabular sin procesar. A diferencia de los marcos AutoML existentes, que se centran principalmente en la selección de modelos e hiperparámetros, AutoGluon -Tabular tiene éxito al ensamblar varios modelos y apilarlos en varias capas. Esta página incluye información sobre las recomendaciones de instancias de Amazon EC2 y cuadernos de muestra para -Tabular. AutoGluon
# Cómo utilizar AI -Tabular SageMaker AutoGluon
Puedes usar AutoGluon -Tabular como un algoritmo integrado de Amazon SageMaker AI. En la siguiente sección se describe cómo usar AutoGluon -Tabular con el SDK de SageMaker Python. Para obtener información sobre cómo usar AutoGluon -Tabular desde la interfaz de usuario clásica de Amazon SageMaker Studio, consulte. [SageMaker JumpStart modelos preentrenados](studio-jumpstart.md)
+ **Utilice AutoGluon -Tabular como algoritmo integrado**
Utilice el algoritmo integrado AutoGluon -Tabular para crear un contenedor de entrenamiento AutoGluon -Tabular, como se muestra en el siguiente ejemplo de código. Puede detectar automáticamente el URI de la imagen del algoritmo integrado AutoGluon -Tabular mediante la `image_uris.retrieve` API de SageMaker IA (o la `get_image_uri` API si utiliza Amazon [ SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) versión 2).
Tras especificar el URI de la imagen AutoGluon -Tabular, puede utilizar el contenedor AutoGluon -Tabular para crear un estimador mediante la API SageMaker AI Estimator e iniciar un trabajo de formación. El algoritmo integrado AutoGluon -Tabular se ejecuta en modo script, pero el script de entrenamiento se proporciona automáticamente y no es necesario reemplazarlo. Si tiene una amplia experiencia en el uso del modo guion para crear un trabajo de SageMaker formación, puede incorporar sus propios guiones de formación en AutoGluon -Tabular.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "autogluon-classification-ensemble", "*", "training"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_binary/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"auto_stack"
] = "True"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_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 SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"training": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Para obtener más información sobre cómo configurar el AutoGluon -Tabular como algoritmo integrado, consulta los siguientes ejemplos de cuadernos. Todos los cubos de S3 utilizados en estos ejemplos deben estar en la misma AWS región que la instancia de bloc de notas utilizada para ejecutarlos.
+ [Clasificación tabular con Amazon SageMaker AI AutoGluon: algoritmo tabular](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Classification_AutoGluon.ipynb)
+ [Regresión tabular con Amazon SageMaker AI AutoGluon: algoritmo tabular](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Regression_AutoGluon.ipynb)
# Interfaz de entrada y salida para el algoritmo -Tabular AutoGluon
La potenciación de gradientes funciona en los datos tabulares, con las filas que representan observaciones, una columna que representa la variable de destino o la etiqueta, y las columnas restantes que representan las características.
La implementación de SageMaker IA de AutoGluon -Tabular admite CSV para el entrenamiento y la inferencia:
+ *Para el **entrenamiento ContentType**, las entradas válidas deben ser text/csv.*
+ *Para la **inferencia ContentType**, las entradas válidas deben ser text/csv.*
**nota**
Para la capacitación de CSV, el algoritmo asume la variable de destino en la primera columna y ese CSV no dispone de un registro de encabezado.
Para la inferencia de CSV, el algoritmo asume que la entrada de CSV no dispone de la columna de etiqueta.
**Formato de entrada para los datos de entrenamiento, los datos de validación y las características categóricas**
Ten cuidado con el formato de los datos de entrenamiento para introducirlos en el modelo -Tabular. AutoGluon Debe proporcionar la ruta a un bucket de Amazon S3 que contenga los datos de entrenamiento y de validación. También puede incluir una lista de características categóricas. Utilice los canales `training` y `validation` para proporcionar los datos de entrada. o utilice solo el canal `training` si lo prefiere.
**Uso de ambos canales (`training` y `validation`)**
Puede proporcionar los datos de entrada mediante dos rutas S3, una para el canal `training` y otra para el canal `validation`. Cada ruta de S3 puede ser un prefijo de S3 o una ruta de S3 completa que apunte a un archivo CSV específico. Las variables de destino deben estar en la primera columna del archivo CSV. Las variables predictoras (características) deben estar en las columnas restantes. Los datos de validación se utilizan para calcular una puntuación de validación al final de cada iteración de potenciación. Hay una interrupción anticipada cuando la puntuación de validación deja de mejorar.
Si los predictores incluyen características categóricas, puede proporcionar un archivo JSON con el nombre `categorical_index.json` en la misma ubicación que el archivo de datos de entrenamiento. Si proporciona un archivo JSON para las características categóricas, el canal `training` debe apuntar a un prefijo S3, y no a un archivo CSV específico. Este archivo debe contener un diccionario de Python donde la clave sea la cadena `"cat_index_list"` y el valor sea una lista de enteros únicos. Cada número entero de la lista de valores debe indicar el índice de columnas de las características categóricas correspondientes en el archivo CSV de datos de entrenamiento. Cada valor debe ser un entero positivo (mayor de cero, ya que cero representa el valor objetivo), menor que el `Int32.MaxValue` (2147483647) y menor que el número total de columnas. Solo debe haber un archivo JSON de índice categórico.
**Uso del canal `training` exclusivamente**
También puede proporcionar sus datos de entrada mediante una única ruta S3 para el canal `training`. Esta ruta de S3 debe apuntar a un directorio con un subdirectorio denominado `training/` que contenga un archivo CSV. Si lo desea, puede incluir otro subdirectorio en la misma ubicación, denominado `validation/`, que también tenga un archivo CSV. Si no se proporcionan los datos de validación, se toma una muestra aleatoria del 20 % de los datos de entrenamiento para que ejerzan como datos de validación. Si los predictores contienen características categóricas, puede proporcionar un archivo JSON con el nombre `categorical_index.json` en la misma ubicación que los subdirectorios de datos.
**nota**
En el modo de entrada de entrenamiento de CSV, la memoria total disponible para el algoritmo (el recuento de instancias multiplicado por la memoria disponible en `InstanceType`) debe poder contener el conjunto de datos de entrenamiento.
SageMaker AI AutoGluon -Tabular usa el `autogluon.tabular.TabularPredictor` módulo para serializar o deserializar el modelo, lo que se puede usar para guardar o cargar el modelo.
**Para usar un modelo entrenado con AI -Tabular con el marco SageMaker AutoGluon AutoGluon**
+ Utilice el siguiente código de Python:
```
import tarfile
from autogluon.tabular import TabularPredictor
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
model = TabularPredictor.load(model_file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Recomendación de instancia de Amazon EC2 para el AutoGluon algoritmo -Tabular
SageMaker AI AutoGluon -Tabular admite el entrenamiento de CPU y GPU de instancia única. A pesar de que los costes por instancia son más altos, GPUs entrene más rápido, lo que las hace más rentables. Para aprovechar la capacitación en GPU, especifique el tipo de instancia como una de las instancias de GPU (por ejemplo, P3). SageMaker Actualmente, AI AutoGluon -Tabular no admite el entrenamiento con varias GPU.
## AutoGluon-Ejemplos de cuadernos tabulares
En la siguiente tabla se describen varios ejemplos de libretas que abordan distintos casos de uso del algoritmo AutoGluon tabular Amazon SageMaker AI.
****
| **Título del cuaderno** | **Descripción** |
| --- | --- |
| [Clasificación tabular con Amazon SageMaker AI AutoGluon: algoritmo tabular](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Classification_AutoGluon.ipynb) | En este cuaderno se muestra el uso del algoritmo Amazon SageMaker AutoGluon AI-Tabular para entrenar y alojar un modelo de clasificación tabular. |
| [Regresión tabular con Amazon SageMaker AI AutoGluon: algoritmo tabular](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/autogluon_tabular/Amazon_Tabular_Regression_AutoGluon.ipynb) | En este cuaderno se muestra el uso del algoritmo Amazon SageMaker AutoGluon AI-Tabular para entrenar y alojar un modelo de regresión tabular. |
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 una instancia de bloc de notas y abrirla, selecciona 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 AutoGluon funciona -Tabular
AutoGluon-Tabular realiza métodos avanzados de procesamiento de datos, aprendizaje profundo y conjunto de modelos multicapa. Reconoce automáticamente el tipo de datos de cada columna, lo que permite hacer un preprocesamiento potente de los datos; esto incluye una gestión especial de los campos de texto.
AutoGluon se adapta a varios modelos, desde árboles off-the-shelf potenciados hasta redes neuronales personalizadas. Estos modelos se agrupan de una manera novedosa: los modelos se apilan en varias capas y se entrenan por capas, lo que garantiza que los datos sin procesar puedan traducirse en predicciones de alta calidad en un plazo determinado. Este proceso mitiga el sobreajuste al dividir los datos de varias maneras con un seguimiento cuidadoso de los ejemplos. out-of-fold
El algoritmo AutoGluon -Tabular funciona bien en las competiciones de aprendizaje automático debido a su manejo robusto de una variedad de tipos de datos, relaciones y distribuciones. Puede utilizar AutoGluon -Tabular para problemas de regresión, clasificación (binaria y multiclase) y clasificación.
Consulte el siguiente diagrama, donde verá el funcionamiento de la estrategia de apilamiento multicapa.
![\[AutoGluonSu estrategia de apilamiento multicapa se muestra con dos capas de apilamiento.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/autogluon_tabular_illustration.png)
Para obtener más información, consulte *[AutoGluon-Tabular: AutomL robusto y preciso](https://arxiv.org/pdf/2003.06505.pdf)* para datos estructurados.
# AutoGluon-Hiperparámetros tabulares
La siguiente tabla contiene el subconjunto de hiperparámetros que se requieren o se utilizan con más frecuencia para el algoritmo tabular Amazon SageMaker AI AutoGluon. Los usuarios establecen estos parámetros para facilitar la estimación de los parámetros del modelo a partir de los datos. [El algoritmo SageMaker AutoGluon AI-Tabular es una implementación del paquete -Tabular de código abierto. AutoGluon](https://github.com/awslabs/autogluon)
**nota**
Los hiperparámetros predeterminados se basan en conjuntos de datos de ejemplo de [AutoGluon-Ejemplos de cuadernos tabulares](autogluon-tabular.md#autogluon-tabular-sample-notebooks).
De forma predeterminada, el algoritmo SageMaker AutoGluon AI-Tabular elige automáticamente una métrica de evaluación en función del tipo de problema de clasificación. El algoritmo AutoGluon-Tabular detecta el tipo de problema de clasificación a partir del número de etiquetas en los datos. Para los problemas de regresión, la métrica de evaluación es la raíz del error cuadrático medio. Para problemas de clasificación binaria, la métrica de evaluación es el área bajo la curva característica de funcionamiento del receptor (AUC). Para los problemas de clasificación multiclase, la métrica de evaluación es la precisión. Puede usar el hiperparámetro `eval_metric` para cambiar la métrica de evaluación predeterminada. Consulte la siguiente tabla para obtener más información sobre los hiperparámetros AutoGluon tabulares, incluidas las descripciones, los valores válidos y los valores predeterminados.
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| eval\$1metric | Métricas de evaluación de los datos de validación. Si `eval_metric` se establece en el valor `"auto"` predeterminado, el algoritmo elige automáticamente una métrica de evaluación en función del tipo de problema de clasificación: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/autogluon-tabular-hyperparameters.html) Valores válidos: cadena; consulte la [AutoGluon documentación](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html) para ver los valores válidos. Valor predeterminado: `"auto"`. |
| presets | Lista de configuraciones predefinidas para varios argumentos en `fit()`. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/autogluon-tabular-hyperparameters.html) Para obtener más información, consulte [AutoGluon Predictores.](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html) Valores válidos: cadena (cualquiera de `"best_quality"`, `"high_quality"`, `good_quality"`, `"medium_quality"`, `"optimize_for_deployment"` o ` or "interpretable"`). Valor predeterminado: `"medium_quality"`. |
| auto\$1stack | Si AutoGluon debería utilizar automáticamente el empaquetado y el ensamblaje de pilas multicapa para aumentar la precisión predictiva. Configure `auto_stack` en `"True"` si está dispuesto a tolerar tiempos de entrenamiento más largos para maximizar la precisión predictiva. Esto establece automáticamente los argumentos `num_bag_folds` y `num_stack_levels` en función de las propiedades del conjunto de datos. Valores válidos: cadena, `"True"` o `"False"`. Valor predeterminado: `"False"`. |
| num\$1bag\$1folds | Número de particiones utilizadas para el bagging de los modelos. Cuando `num_bag_folds` es igual a `k`, el tiempo de entrenamiento se incrementa aproximadamente en un factor de `k`. Ponga `num_bag_folds` a 0 para desactivar el bagging. Esta opción está desactivada de forma predeterminada, pero recomendamos utilizar valores de entre 5 y 10 para maximizar el rendimiento predictivo. El aumento de `num_bag_folds` da como resultado modelos con un sesgo más bajo, pero que son más propensos a sobreajustarse. 1 es un valor no válido para este parámetro y generará un `ValueError`. Los valores superiores a 10 pueden producir rendimientos decrecientes e incluso pueden influir negativamente en los resultados generales debido al sobreajuste. Para mejorar aún más las predicciones, evite aumentar `num_bag_folds`; en su lugar, aumente `num_bag_sets`. Valores válidos: cadena, cualquier número entero entre `"0"` y `"10"` (ambos incluidos). Valor predeterminado: `"0"`. |
| num\$1bag\$1sets | Número de repeticiones del bagging de kfold que se van a realizar (los valores deben ser mayores o iguales a 1). El número total de modelos entrenados durante el bagging es igual a `num_bag_folds` \$1 `num_bag_sets`. El valor predeterminado de este parámetro es 1 si no se especifica `time_limit`. Este parámetro está deshabilitado si no se especifica `num_bag_folds`. Los valores superiores a 1 dan como resultado un rendimiento predictivo superior, especialmente en problemas más pequeños y con el apilamiento activado. Valores válidos: entero, rango [`1`, `20`]. Valor predeterminado: `1`. |
| num\$1stack\$1levels | Número de niveles de apilamiento que se van a utilizar en el conjunto de pilas. Aumenta aproximadamente el tiempo de entrenamiento del modelo en un factor de `num_stack_levels` \$1 1. Establezca este parámetro en 0 para desactivar el ensamblado de pilas. Este parámetro está desactivado de forma predeterminada, pero recomendamos utilizar valores de entre 1 y 3 para maximizar el rendimiento predictivo. Para evitar un sobreajuste y un `ValueError`, `num_bag_folds` debe ser mayor o igual a 2. Valores válidos: flotante, con el rango [`0`, `3`]. Valor predeterminado: `0`. |
| refit\$1full | Si se deben volver a entrenar o no todos los modelos con todos los datos (entrenamiento y validación) tras el procedimiento de entrenamiento normal. [Para obtener más información, consulte Predictores. AutoGluon ](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.html) Valores válidos: cadena, `"True"` o `"False"`. Valor predeterminado: `"False"`. |
| set\$1best\$1to\$1refit\$1full | Si se debe cambiar o no el modelo predeterminado que el predictor utiliza para la predicción. Si `set_best_to_refit_full` se establece en `"True"`, el modelo predeterminado cambia al modelo que presentó la puntuación de validación más alta como resultado del reajuste (activado por `refit_full`). Solo es válido si `refit_full` está establecido. Valores válidos: cadena, `"True"` o `"False"`. Valor predeterminado: `"False"`. |
| save\$1space | Si se debe reducir la memoria y el tamaño del disco del predictor mediante la eliminación de los archivos de modelo auxiliares que no son necesarios para la predicción de datos nuevos. Esto no afecta a la precisión de las inferencias. Recomendamos establecer `save_space` en `"True"` si el único objetivo es utilizar el modelo entrenado para la predicción. Es posible que algunas funciones avanzadas ya no estén disponibles si `save_space` se establece en `"True"`. Consulte la documentación de `[predictor.save\$1space()](https://auto.gluon.ai/stable/api/autogluon.tabular.TabularPredictor.save_space.html)` para obtener más información. Valores válidos: cadena, `"True"` o `"False"`. Valor predeterminado: `"False"`. |
| verbosity | La verbosidad de los mensajes de impresión. Los niveles de `verbosity` van de `0` a `4`, y los niveles más altos corresponden a declaraciones de impresión más detalladas. Una `verbosity` de `0` suprime las advertencias. Valores válidos: entero (`0`, `1`, `2`, `3` o `4`). Valor predeterminado: `2`. |
# Ajuste de un modelo AutoGluon tabular
Si bien AutoGluon -Tabular se puede utilizar para ajustar modelos, su diseño puede ofrecer un buen rendimiento mediante métodos de apilamiento y ensamblaje, lo que significa que no es necesaria la optimización de hiperparámetros. En lugar de centrarse en el ajuste del modelo, AutoGluon -Tabular consigue apilar los modelos en varias capas y entrenarlos por capas.
Para obtener más información sobre los hiperparámetros tabulares, consulte. AutoGluon [AutoGluon-Hiperparámetros tabulares](autogluon-tabular-hyperparameters.md)
# CatBoost
[CatBoost](https://catboost.ai/)es una implementación de código abierto popular y de alto rendimiento del algoritmo Gradient Boosting Decision Tree (GBDT). GBDT es un algoritmo de aprendizaje supervisado que intenta predecir adecuadamente una variable objetivo mediante la combinación de un conjunto de estimaciones a partir de un conjunto de modelos más simples y más débiles.
CatBoost presenta dos avances algorítmicos fundamentales en el GBDT:
1. La implementación de la potenciación ordenada, una alternativa al algoritmo clásico basada en permutaciones
1. Un algoritmo innovador para procesar características categóricas
Ambas técnicas se crearon para combatir un cambio de predicción provocado por un tipo especial de fuga de objetivo presente en todas las implementaciones actuales de algoritmos de potenciación por gradiente. Esta página incluye información sobre las recomendaciones de instancias de Amazon EC2 y cuadernos de muestra para. CatBoost
# ¿Cómo usar la IA? SageMaker CatBoost
Se puede utilizar CatBoost como un algoritmo integrado de Amazon SageMaker AI. En la siguiente sección se describe cómo usarlo CatBoost con el SDK de SageMaker Python. Para obtener información sobre cómo usarlo CatBoost desde la interfaz de usuario clásica de Amazon SageMaker Studio, consulte[SageMaker JumpStart modelos preentrenados](studio-jumpstart.md).
+ ** CatBoost Utilícelo como algoritmo integrado**
Utilice el algoritmo CatBoost integrado para crear un contenedor de CatBoost entrenamiento, como se muestra en el siguiente ejemplo de código. Puede detectar automáticamente el URI de la imagen del algoritmo CatBoost integrado mediante la `image_uris.retrieve` API de SageMaker IA (o la `get_image_uri` API si utiliza [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) versión 2).
Tras especificar el URI de la CatBoost imagen, puede utilizar el CatBoost contenedor para crear un estimador mediante la API SageMaker AI Estimator e iniciar un trabajo de formación. El algoritmo CatBoost integrado se ejecuta en modo script, pero el script de entrenamiento se proporciona automáticamente y no es necesario reemplazarlo. Si tiene una amplia experiencia en el uso del modo guion para crear un trabajo de SageMaker formación, puede incorporar sus propios guiones de CatBoost formación.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "catboost-classification-model", "*", "training"
training_instance_type = "ml.m5.xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_multiclass/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"iterations"
] = "500"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_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 SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"training": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Para obtener más información sobre cómo configurarlo CatBoost como un algoritmo integrado, consulte los siguientes ejemplos de cuadernos.
+ [Clasificación tabular con Amazon SageMaker AI LightGBM y algoritmo CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)
+ [Regresión tabular con Amazon SageMaker AI LightGBM y algoritmo CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)
# Interfaz de entrada y salida para el algoritmo CatBoost
La potenciación de gradientes funciona en los datos tabulares, con las filas que representan observaciones, una columna que representa la variable de destino o la etiqueta, y las columnas restantes que representan las características.
La implementación de SageMaker IA CatBoost admite el CSV para el entrenamiento y la inferencia:
+ Para la **formación ContentType**, las entradas válidas deben ser *texto/csv*.
+ *Para la **inferencia ContentType**, las entradas válidas deben ser text/csv.*
**nota**
Para la capacitación de CSV, el algoritmo asume la variable de destino en la primera columna y ese CSV no dispone de un registro de encabezado.
Para la inferencia de CSV, el algoritmo asume que la entrada de CSV no dispone de la columna de etiqueta.
**Formato de entrada para los datos de entrenamiento, los datos de validación y las características categóricas**
Ten cuidado con el formato de los datos de entrenamiento para introducirlos en el modelo. CatBoost Debe proporcionar la ruta a un bucket de Amazon S3 que contenga los datos de entrenamiento y de validación. También puede incluir una lista de características categóricas. Utilice los canales `training` y `validation` para proporcionar los datos de entrada. o utilice solo el canal `training` si lo prefiere.
**Uso de ambos canales (`training` y `validation`)**
Puede proporcionar los datos de entrada mediante dos rutas S3, una para el canal `training` y otra para el canal `validation`. Cada ruta S3 puede ser un prefijo S3 que apunte a uno o más archivos CSV, o una ruta S3 completa que apunte a un archivo CSV específico. Las variables de destino deben estar en la primera columna del archivo CSV. Las variables predictoras (características) deben estar en las columnas restantes. Si se proporcionan varios archivos CSV para los `validation` canales `training` o, el CatBoost algoritmo concatena los archivos. Los datos de validación se utilizan para calcular una puntuación de validación al final de cada iteración de potenciación. Hay una interrupción anticipada cuando la puntuación de validación deja de mejorar.
Si los predictores incluyen características categóricas, puede proporcionar un archivo JSON con el nombre `categorical_index.json` en la misma ubicación que los archivos de datos de entrenamiento. Si proporciona un archivo JSON para las características categóricas, el canal `training` debe apuntar a un prefijo S3, y no a un archivo CSV específico. Este archivo debe contener un diccionario de Python donde la clave sea la cadena `"cat_index_list"` y el valor sea una lista de enteros únicos. Cada número entero de la lista de valores debe indicar el índice de columnas de las características categóricas correspondientes en el archivo CSV de datos de entrenamiento. Cada valor debe ser un entero positivo (mayor de cero, ya que cero representa el valor objetivo), menor que el `Int32.MaxValue` (2147483647) y menor que el número total de columnas. Solo debe haber un archivo JSON de índice categórico.
**Uso del canal `training` exclusivamente**
También puede proporcionar sus datos de entrada mediante una única ruta S3 para el canal `training`. Esta ruta S3 debe apuntar a un directorio con un subdirectorio denominado `training/` que contenga uno o más archivos CSV. Si lo desea, puede incluir otro subdirectorio en la misma ubicación, denominado `validation/`, que también tenga uno o más archivos CSV. Si no se proporcionan los datos de validación, se toma una muestra aleatoria del 20 % de los datos de entrenamiento para que ejerzan como datos de validación. Si los predictores contienen características categóricas, puede proporcionar un archivo JSON con el nombre `categorical_index.json` en la misma ubicación que los subdirectorios de datos.
**nota**
En el modo de entrada de entrenamiento de CSV, la memoria total disponible para el algoritmo (el recuento de instancias multiplicado por la memoria disponible en `InstanceType`) debe poder contener el conjunto de datos de entrenamiento.
SageMaker La IA CatBoost usa los `catboost.CatBoostRegressor` módulos `catboost.CatBoostClassifier` y para serializar o deserializar el modelo, que se pueden usar para guardar o cargar el modelo.
**Para usar un modelo entrenado con IA con SageMaker CatBoost `catboost`**
+ Utilice el siguiente código de Python:
```
import tarfile
from catboost import CatBoostClassifier
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
file_path = os.path.join(model_file_path, "model")
model = CatBoostClassifier()
model.load_model(file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Recomendación de instancia de Amazon EC2 para el algoritmo CatBoost
SageMaker CatBoost Actualmente, la IA solo entrena usando CPUs. CatBoost es un algoritmo limitado a la memoria (a diferencia de un algoritmo limitado a la computación). Por lo tanto, una instancia de computación de uso general (por ejemplo, M5) es una opción mejor que una instancia optimizada para la computación (por ejemplo, C5). Además, recomendamos que disponga de suficiente memoria en total en las instancias seleccionadas para almacenar los datos de capacitación.
## CatBoost cuadernos de muestra
La siguiente tabla describe una variedad de cuadernos de muestra que abordan diferentes casos de uso del CatBoost algoritmo Amazon SageMaker AI.
****
| **Título del cuaderno** | **Descripción** |
| --- | --- |
| [Clasificación tabular con Amazon SageMaker AI LightGBM y algoritmo CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb) | Este cuaderno muestra el uso del CatBoost algoritmo Amazon SageMaker AI para entrenar y alojar un modelo de clasificación tabular. |
| [Regresión tabular con Amazon SageMaker AI LightGBM y algoritmo CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb) | Este cuaderno muestra el uso del CatBoost algoritmo Amazon SageMaker AI para entrenar y alojar un modelo de regresión tabular. |
Para obtener instrucciones sobre cómo crear instancias de Jupyter Notebook y acceder a ellas, que puede utilizar para ejecutar el ejemplo en SageMaker IA, consulte. [Instancias de Amazon SageMaker Notebook](nbi.md) Tras crear una instancia de bloc de notas y abrirla, selecciona 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 CatBoost funciona
CatBoost implementa un algoritmo convencional de árbol de decisiones para impulsar el gradiente (GBDT) con la adición de dos avances algorítmicos fundamentales:
1. La implementación de la potenciación ordenada, una alternativa al algoritmo clásico basada en permutaciones
1. Un algoritmo innovador para procesar características categóricas
Ambas técnicas se crearon para combatir un cambio de predicción provocado por un tipo especial de fuga de objetivo presente en todas las implementaciones actuales de algoritmos de potenciación por gradiente.
El CatBoost algoritmo tiene un buen rendimiento en las competiciones de aprendizaje automático debido a su buen manejo de una variedad de tipos de datos, relaciones y distribuciones y a la diversidad de hiperparámetros que se pueden ajustar con precisión. Se puede utilizar CatBoost para problemas de regresión, clasificación (binaria y multiclase) y clasificación.
Para obtener más información sobre la potenciación por gradiente, consulte [Cómo funciona el XGBoost algoritmo de SageMaker IA](xgboost-HowItWorks.md). Para obtener información detallada sobre las técnicas adicionales de GOSS y EFB utilizadas en el CatBoost método, consulte *[CatBoost: aumento imparcial](https://arxiv.org/pdf/1706.09516.pdf)* con características categóricas.
# CatBoost hiperparámetros
La siguiente tabla contiene el subconjunto de hiperparámetros que se requieren o se utilizan con más frecuencia para el algoritmo Amazon SageMaker AI CatBoost . Los usuarios establecen estos parámetros para facilitar la estimación de los parámetros del modelo a partir de los datos. El CatBoost algoritmo de SageMaker IA es una implementación del paquete de código abierto [CatBoost](https://github.com/catboost/catboost).
**nota**
Los hiperparámetros predeterminados se basan en conjuntos de datos de ejemplo de [CatBoost cuadernos de muestra](catboost.md#catboost-sample-notebooks).
De forma predeterminada, el CatBoost algoritmo de SageMaker IA elige automáticamente una métrica de evaluación y una función de pérdida en función del tipo de problema de clasificación. El CatBoost algoritmo detecta el tipo de problema de clasificación en función del número de etiquetas de los datos. Para los problemas de regresión, las funciones de pérdida y métrica de evaluación son la raíz del error cuadrático medio. Para los problemas de clasificación binaria, la métrica de evaluación es el área bajo la curva (AUC) y la función de pérdida es la pérdida logarítmica (log loss). Para los problemas de clasificación multiclase, la métrica de evaluación y las funciones de pérdida son la entropía cruzada multiclase. Puede usar el hiperparámetro `eval_metric` para cambiar la métrica de evaluación predeterminada. Consulte la siguiente tabla para obtener más información sobre los hiperparámetros en LightGBM, lo que incluye las descripciones, los valores válidos y los valores predeterminados.
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| iterations | La cantidad máxima de árboles que se puede construir. Valores válidos: entero positivo. Valor predeterminado: `500`. |
| early\$1stopping\$1rounds | El entrenamiento se detendrá si una métrica de un punto de datos de validación no mejora en la última ronda `early_stopping_rounds`. Si `early_stopping_rounds` es inferior o igual a cero, se omite este hiperparámetro. Valores válidos: número entero Valor predeterminado: `5`. |
| eval\$1metric | Métricas de evaluación de los datos de validación. Si `eval_metric` se establece en el valor `"auto"` predeterminado, el algoritmo elige automáticamente una métrica de evaluación en función del tipo de problema de clasificación: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/catboost-hyperparameters.html) Valores válidos: cadena; consulte la [CatBoost documentación para ver](https://catboost.ai/en/docs/references/eval-metric__supported-metrics) los valores válidos. Valor predeterminado: `"auto"`. |
| learning\$1rate | La velocidad a la que se actualizan los pesos del modelo después de pasar por cada lote de ejemplos de entrenamiento. Valores válidos: flotante, rango (`0.0`, `1.0`). Valor predeterminado: `0.009`. |
| depth | Profundidad del árbol. Valores válidos: entero, rango (`1`, `16`). Valor predeterminado: `6`. |
| l2\$1leaf\$1reg | Coeficiente del término de regularización L2 de la función de costo. Valores válidos: entero positivo. Valor predeterminado: `3`. |
| random\$1strength | La cantidad de asignación al azar que se utilizará para puntuar las divisiones cuando se selecciona la estructura de árbol. Utilice este parámetro para evitar sobreajustar el modelo. Valores válidos: flotante, rango (número de coma flotante positivo). Valor predeterminado: `1.0`. |
| max\$1leaves | El número máximo de hojas en el árbol resultante. Solo se puede usar con la política de cultivo `"Lossguide"`. Valores válidos: entero, rango [`2`, `64`]. Valor predeterminado: `31`. |
| rsm | Método de subespacio aleatorio. El porcentaje de características que se van a utilizar en cada selección dividida cuando las características se vuelven a seleccionar de forma aleatoria. Valores válidos: flotante, rango (`0.0`, `1.0`). Valor predeterminado: `1.0`. |
| sampling\$1frequency | Frecuencia con la que tomar muestras de ponderaciones y objetos al construir árboles. Valores válidos: cadena (`"PerTreeLevel"` o `"PerTree"`). Valor predeterminado: `"PerTreeLevel"`. |
| min\$1data\$1in\$1leaf | El número mínimo de muestras de entrenamiento en una hoja. CatBoost no busca nuevas divisiones en las hojas con un recuento de muestras inferior al valor especificado. Solo se puede usar con las políticas de cultivo `"Lossguide"` y `"Depthwise"`. Valores válidos: entero, rango (`1` o `∞`). Valor predeterminado: `1`. |
| bagging\$1temperature | Define la configuración del arranque bayesiano. Use el arranque bayesiano para asignar ponderaciones aleatorias a los objetos. Si `bagging_temperature` se establece en `1.0`, las ponderaciones se muestrean a partir de una distribución exponencial. Si `bagging_temperature` se establece en `0.0`, todas las ponderaciones serán 1,0. Valores válidos: número flotante no negativo. Valor predeterminado: `1.0`. |
| boosting\$1type | El esquema de potenciación. “Automático” significa que `boosting_type` se selecciona en función del tipo de unidad de procesamiento, el número de objetos del conjunto de datos de entrenamiento y el modo de aprendizaje seleccionado. Valores válidos: cadena (`"Auto"`, `"Ordered"` o `"Plain"`). Valor predeterminado: `"Auto"`. |
| scale\$1pos\$1weight | La ponderación de la clase positiva en la clasificación binaria. El valor se utiliza como multiplicador de las ponderaciones de los objetos de clase positiva. Valores válidos: número flotante positivo. Valor predeterminado: `1.0`. |
| max\$1bin | El número de divisiones de las características numéricas. `"Auto"` significa que `max_bin` se selecciona en función del tipo de unidad de procesamiento y otros parámetros. Para obtener más información, consulte la CatBoost documentación. Valores válidos: cadena (`"Auto"` o cadena de números enteros desde `"1"` hasta `"65535"`, ambos incluidos). Valor predeterminado: `"Auto"`. |
| grow\$1policy | Política de cultivo de árboles. Define cómo llevar a cabo una construcción ambiciosa de árboles. Valores válidos: cadena (`"SymmetricTree"`, `"Depthwise"` o `"Lossguide"`). Valor predeterminado: `"SymmetricTree"`. |
| random\$1seed | La semilla aleatoria utilizada para el entrenamiento. Valores válidos: número entero no negativo. Valor predeterminado: `1.0`. |
| thread\$1count | La cantidad de subprocesos que se va a utilizar durante el entrenamiento. Si `thread_count` es `-1`, la cantidad de subprocesos es igual a la cantidad de núcleos de procesador. `thread_count` no puede ser `0`. Valores válidos: un número entero (`-1` o un entero positivo). Valor predeterminado: `-1`. |
| verbose | La verbosidad de los mensajes de impresión; los niveles más altos corresponden a declaraciones de impresión más detalladas. Valores válidos: entero positivo. Valor predeterminado: `1`. |
# Ajuste un CatBoost modelo
El *ajuste de modelo automático*, también conocido como ajuste de hiperparámetros, encuentra la mejor versión de un modelo ejecutando distintas tareas que prueban una serie de hiperparámetros en los conjuntos de datos de validación y entrenamiento. El ajuste del modelo se centra en los siguientes hiperparámetros:
**nota**
La función de pérdida de aprendizaje se asigna automáticamente en función del tipo de tarea de clasificación, que viene determinada por el número de enteros únicos de la columna de etiquetas. Para obtener más información, consulte [CatBoost hiperparámetros](catboost-hyperparameters.md).
+ Una función de pérdida de aprendizaje que se debe optimizar durante el entrenamiento con modelos.
+ Una métrica de evaluación que se utiliza para evaluar el rendimiento del modelo durante la validación.
+ Un conjunto de hiperparámetros y un rango de valores para emplear al ajustar el modelo automáticamente.
El ajuste de modelo automático busca los hiperparámetros elegidos con el objetivo de encontrar una combinación de valores que genere un modelo capaz de optimizar la métrica de evaluación seleccionada.
**nota**
El ajuste automático de modelos solo CatBoost está disponible en Amazon SageMaker SDKs, no en la consola de SageMaker IA.
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 de evaluación calculadas por el CatBoost algoritmo
El CatBoost algoritmo de SageMaker IA calcula las siguientes métricas para utilizarlas en la validación del modelo. La métrica de evaluación se asigna automáticamente en función del tipo de tarea de clasificación, que viene determinada por el número de enteros únicos en la columna de etiqueta.
| Nombre de métrica | Description (Descripción) | Dirección de optimización | Patrón de expresiones regulares |
| --- | --- | --- | --- |
| RMSE | raíz del error cuadrático medio | minimizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| MAE | error absoluto medio | minimizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| MedianAbsoluteError | error absoluto mediano | minimizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| R2 | puntuación r2 | maximizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| Logloss | entropía cruzada binaria | maximizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| Precision | precisión | maximizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| Recall | exhaustividad | maximizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| F1 | puntuación f1 | maximizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| AUC | puntuación auc | maximizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| MultiClass | entropía cruzada multiclase | maximizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| Accuracy | precisión | maximizar | "bestTest = ([0-9\$1\$1.]\$1)" |
| BalancedAccuracy | precisión equilibrada | maximizar | "bestTest = ([0-9\$1\$1.]\$1)" |
## Hiperparámetros ajustables CatBoost
Ajuste el CatBoost modelo con los siguientes hiperparámetros. Los hiperparámetros que tienen el mayor efecto en la optimización de las métricas de CatBoost evaluación son:`learning_rate`, `depth``l2_leaf_reg`, y. `random_strength` Para obtener una lista de todos los CatBoost hiperparámetros, consulte. [CatBoost hiperparámetros](catboost-hyperparameters.md)
| Nombre del parámetro | Tipo de parámetro | Intervalos recomendados |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001, MaxValue: 0,01 |
| depth | IntegerParameterRanges | MinValue: 4, MaxValue 10 |
| l2\$1leaf\$1reg | IntegerParameterRanges | MinValue: 2, MaxValue 10 |
| random\$1strength | ContinuousParameterRanges | MinValue: 0, MaxValue 10 |
# Algoritmo de máquinas de factorización
El algoritmo de máquinas de factorización es un algoritmo de aprendizaje supervisado de uso general que puede utilizar para tareas de clasificación y regresión. Es una extensión de un modelo lineal que se ha diseñado para capturar de manera económica interacciones entre características dentro de conjuntos de datos dispersos de grandes dimensiones. Por ejemplo, en un sistema de predicción de clics, el modelo de máquinas de factorización puede capturar los patrones de tasas de clics observados cuando los anuncios de una determinada categoría de anuncios se colocan en páginas de una categoría de página específica. Las máquinas de factorización son una buena opción para las tareas que tratan con conjuntos de datos dispersos de grandes dimensiones, como la recomendación de productos y predicciones de clics.
**nota**
La implementación de Amazon SageMaker AI del algoritmo Factorization Machines solo considera las interacciones por pares (segundo orden) entre características.
**Topics**
+ [Interfaz de entrada/salida para el algoritmo de máquinas de factorización](#fm-inputoutput)
+ [Recomendación de la instancia EC2 para el algoritmo de máquinas de factorización](#fm-instances)
+ [Cuadernos de ejemplo de máquinas de factorización](#fm-sample-notebooks)
+ [Funcionamiento de las máquinas de factorización](fact-machines-howitworks.md)
+ [Hiperparámetros de máquinas de factorización](fact-machines-hyperparameters.md)
+ [Ajuste de un modelo de máquinas de factorización](fm-tuning.md)
+ [Formatos de respuesta de máquinas de factorización](fm-in-formats.md)
## Interfaz de entrada/salida para el algoritmo de máquinas de factorización
El algoritmo de máquinas de factorización se puede ejecutar en el modo de regresión o en el modo de clasificación binaria. En cada modo, puede proporcionarse un conjunto de datos en el canal de **prueba** junto con el conjunto de datos de canal de capacitación. La puntuación depende del modo utilizado. En el modo de regresión, el conjunto de datos de prueba se puntúa mediante la desviación cuadrática media (RMSE, Root Mean Square Error). En el modo de clasificación binario, el conjunto de datos de prueba se puntúa mediante la entropía cruzada binaria (pérdida de registro), la precisión (umbral = 0,5) y la puntuación F1 (umbral = 0,5).
Para el **entrenamiento**, el algoritmo de máquinas de factorización admite actualmente solo el formato `recordIO-protobuf` con tensores `Float32`. Puesto que su caso de uso es predominante en los datos dispersos, `CSV` no es un buen candidato. La capacitación de los modos File y Pipe es compatible con el formato protobuf integrado recordIO.
Para la **inferencia**, el algoritmo de máquinas de factorización admite los formatos `application/json` y `x-recordio-protobuf`.
+ Para el problema de **clasificación binaria**, el algoritmo predice una puntuación y una etiqueta. La etiqueta es un número y puede ser `0` o `1`. La puntuación es un número que indica en qué medida el algoritmo cree que la etiqueta debe ser `1`. El algoritmo calcula la puntuación en primer lugar y, a continuación, obtiene la etiqueta del valor de puntuación. Si la puntuación superior o igual a 0,5, la etiqueta es `1`.
+ Para el **problema de regresión**, solo se devuelve una puntuación y es el valor esperado. Por ejemplo, si se utiliza máquinas de factorización para predecir una calificación de película, la puntuación es el valor de calificación esperado.
Consulte [Cuadernos de ejemplo de máquinas de factorización](#fm-sample-notebooks) para obtener más información sobre capacitación y los formatos de archivo de inferencia.
## Recomendación de la instancia EC2 para el algoritmo de máquinas de factorización
El algoritmo Amazon SageMaker AI Factorization Machines es altamente escalable y puede entrenarse en instancias distribuidas. Recomendamos realizar la capacitación y la inferencia con instancias de CPU para los conjuntos de datos dispersos y densos. En algunas circunstancias, el entrenamiento con uno o más GPUs datos densos puede ofrecer alguna ventaja. La capacitación con solo GPUs está disponible con datos densos. Utilice las instancias de CPU para los datos dispersos. El algoritmo de máquinas de factorización admite instancias P2, P3, G4dn y G5 para el entrenamiento y la inferencia.
## Cuadernos de ejemplo de máquinas de factorización
Para ver un ejemplo de cuaderno que utiliza el algoritmo de máquinas de factorización con SageMaker IA para analizar las imágenes de dígitos manuscritos del cero al nueve en el conjunto de datos del MNIST, consulte [Introducción a las máquinas de factorización](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/factorization_machines_mnist/factorization_machines_mnist.html) con el MNIST. 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 cuadernos de ejemplo del algoritmo de máquinas de factorización se encuentran en la sección **Introducción a los algoritmos de Amazon**. Para abrir un cuaderno, haga clic en la pestaña **Usar** y seleccione **Crear copia**.
# Funcionamiento de las máquinas de factorización
La tarea de predicción para un modelo de máquinas de factorización es calcular una función ŷ desde un conjunto de características xi a un dominio de destino. Este dominio es de valor real para la regresión y binario para la clasificación. El modelo de máquinas de factorización se supervisa, por lo que tiene un conjunto de datos de entrenamiento (xi,yj) disponible. Las ventajas de este modelo están en la forma en que utiliza una parametrización factorizada para capturar las interacciones de características por par. Puede representarse matemáticamente tal y como se indica a continuación:
![\[Una imagen que contiene la ecuación para el modelo de máquinas de factorización.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/FM1.jpg)
Los tres términos en esta ecuación corresponden, respectivamente, a los tres componentes del modelo:
+ El término w0 representa el sesgo global.
+ Los plazos lineales wi modelan la intensidad de la variable número i.
+ Los plazos de factorización modelan la interacción de par entre las variables número i y j.
Los plazos lineales y de sesgo globales son los mismos que en el modelo lineal. Las interacciones de características por pares se modelan en el tercer plazo como el producto interno de los factores correspondientes aprendidos para cada característica. Los factores aprendidos pueden considerarse también vectores de integración para cada característica. Por ejemplo, en una tarea de clasificación, si un par de características suele darse con más frecuencia en muestras etiquetadas positivas, el producto interno de sus factores debería ser grande. Es decir, los vectores de integración deberían estar próximos en la similaridad de coseno. Para obtener más información sobre el modelo de máquinas de factorización, consulte [Factorization Machines](https://www.ismll.uni-hildesheim.de/pub/pdfs/Rendle2010FM.pdf).
Para las tareas de regresión, se realiza el entrenamiento del modelo minimizando el error cuadrático entre la predicción del modelo ŷn y el valor de destino yn. Esto se denomina la pérdida cuadrada:
![\[Una imagen que contiene la ecuación para pérdida cuadrada.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/FM2.jpg)
Para una tarea de clasificación, el modelo se capacita minimizando la pérdida de entropía cruzada, conocida también como pérdida de registro:
![\[Una imagen que contiene la ecuación para pérdida de registro.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/FM3.jpg)
donde:
![\[Una imagen que contiene la función logística de los valores previstos.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/FM4.jpg)
Para obtener más información acerca de funciones de pérdida para la clasificación, consulte la página sobre [funciones de pérdida para clasificación](https://en.wikipedia.org/wiki/Loss_functions_for_classification).
# Hiperparámetros de máquinas de factorización
La siguiente tabla contiene los hiperparámetros para el algoritmo de máquinas de factorización. Estos son los parámetros que establecen los usuarios para facilitar la estimación de los parámetros del modelo a partir de los datos. Los hiperparámetros necesarios que deben establecerse se enumerarán en primer lugar, en orden alfabético. Los hiperparámetros opcionales que se pueden establecer aparecen a continuación en la lista, también en orden alfabético.
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| feature\$1dim | La dimensión del espacio de características de entrada. Podría tener un valor alto con la entrada dispersa. **Obligatorio** Valores válidos: número entero positivo Rango de valor sugerido: [10000,10000000] |
| num\$1factors | La dimensionalidad de la factorización. **Obligatorio** Valores válidos: número entero positivo Rango de valores sugerido: [2,1000], 64 normalmente genera buenos resultados y es un buen punto de partida. |
| predictor\$1type | El tipo de elemento de predicción. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Obligatorio** Valores válidos: String `binary_classifier` o `regressor` |
| bias\$1init\$1method | El método de inicialización para el plazo de sesgo: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Opcional** Valores válidos: `uniform`, `normal` o `constant` Valor predeterminado: `normal` |
| bias\$1init\$1scale | Rango de la inicialización del plazo de sesgo. Surte efecto si `bias_init_method` está establecido en `uniform`. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: ninguno |
| bias\$1init\$1sigma | La desviación estándar para la inicialización del plazo de sesgo. Surte efecto si `bias_init_method` está establecido en `normal`. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: 0,01 |
| bias\$1init\$1value | El valor inicial del plazo de sesgo. Surte efecto si `bias_init_method` está establecido en `constant`. **Opcional** Valores válidos: número flotante. Rango de valor sugerido: [1e-8, 512] Valor predeterminado: ninguno |
| bias\$1lr | La tasa de aprendizaje para el plazo de sesgo. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: 0.1 |
| bias\$1wd | El decremento de ponderación para el plazo de sesgo. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: 0,01 |
| clip\$1gradient | Parámetro del optimizador de recorte de gradientes. Recorta el gradiente proyectándolo en el intervalo [-`clip_gradient`, \$1`clip_gradient`]. **Opcional** Valores válidos: número flotante Valor predeterminado: ninguno |
| epochs | El número de fechas de inicio de capacitación que ejecutar. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 1 |
| eps | Parámetro de valores epsilon para evitar la división por 0. **Opcional** Valores válidos: número flotante. Valor sugerido: pequeño. Valor predeterminado: ninguno |
| factors\$1init\$1method | El método de inicialización para los plazos de factorización: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Opcional** Valores válidos: `uniform`, `normal` o `constant`. Valor predeterminado: `normal` |
| factors\$1init\$1scale | El rango de la inicialización de los plazos de factorización. Surte efecto si `factors_init_method` está establecido en `uniform`. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: ninguno |
| factors\$1init\$1sigma | La desviación estándar para la inicialización de los plazos de factorización. Surte efecto si `factors_init_method` está establecido en `normal`. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: 0.001 |
| factors\$1init\$1value | El valor inicial de los plazos de factorización. Surte efecto si `factors_init_method` está establecido en `constant`. **Opcional** Valores válidos: número flotante. Rango de valor sugerido: [1e-8, 512] Valor predeterminado: ninguno |
| factors\$1lr | La tasa de aprendizaje para los plazos de factorización. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: 0.0001 |
| factors\$1wd | El decremento de ponderación para los plazos de factorización. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: 0.00001 |
| linear\$1lr | La tasa de aprendizaje para plazos lineales. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: 0.001 |
| linear\$1init\$1method | El método de inicialización para los plazos lineales: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Opcional** Valores válidos: `uniform`, `normal` o `constant`. Valor predeterminado: `normal` |
| linear\$1init\$1scale | Rango de la inicialización de los plazos lineales. Surte efecto si `linear_init_method` está establecido en `uniform`. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: ninguno |
| linear\$1init\$1sigma | La desviación estándar para la inicialización de los plazos lineales. Surte efecto si `linear_init_method` está establecido en `normal`. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: 0,01 |
| linear\$1init\$1value | El valor inicial de los plazos lineales. Surte efecto si se establece `linear_init_method` en *constante*. **Opcional** Valores válidos: número flotante. Rango de valor sugerido: [1e-8, 512] Valor predeterminado: ninguno |
| linear\$1wd | El decremento de ponderación para los plazos lineales. **Opcional** Valores válidos: número flotante no negativo Rango de valor sugerido: [1e-8, 512] Valor predeterminado: 0.001 |
| mini\$1batch\$1size | El tamaño del minilote utilizado para la capacitación. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 1000 |
| rescale\$1grad | Parámetro del optimizador de reescalado de gradientes. Si se establece, multiplica el gradiente con `rescale_grad` antes de la actualización. Seleccione con frecuencia que sea 1,0/`batch_size`. **Opcional** Valores válidos: número flotante Valor predeterminado: ninguno |
# Ajuste de un modelo de máquinas de factorización
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 computadas por el algoritmo de máquinas de factorización
El algoritmo de máquinas de factorización tiene tipos de predictores de regresión y de clasificación binaria. El tipo de predictor determina qué tipo de métrica puede utilizar para el ajuste de un modelo automático. El algoritmo informa de una métrica de regresor `test:rmse`, que se calcula durante la capacitació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:rmse | Error cuadrado medio raíz | Minimizar |
El algoritmo de máquinas de factorización notifica tres métricas de clasificación binaria que se calculan durante el entrenamiento. Al ajustar el modelo para tareas de clasificación binaria, elija una de estas como el objetivo.
| Nombre de métrica | Description (Descripción) | Dirección de optimización |
| --- | --- | --- |
| test:binary\$1classification\$1accuracy | Exactitud | Maximizar |
| test:binary\$1classification\$1cross\$1entropy | Entropía cruzada | Minimizar |
| test:binary\$1f\$1beta | Beta | Maximizar |
## Hiperparámetros ajustables de máquinas de factorización
Es posible ajustar los siguientes hiperparámetros para el algoritmo de máquinas de factorización. Los parámetros de inicialización que contienen los términos sesgo, lineal y factorización dependen de su método de inicialización. Existen tres métodos de inicialización: `uniform`, `normal` y `constant`. No es posible ajustar estos métodos de inicialización. Los parámetros que se pueden ajustar dependen de esta opción del método de inicialización. Por ejemplo, si el método de inicialización es `uniform`, solo se pueden ajustar los parámetros correspondientes a `scale`. En concreto, si `bias_init_method==uniform`, entonces `bias_init_scale`, `linear_init_scale` y `factors_init_scale` se pueden ajustar. De manera parecida, si el método de inicialización es `normal`, solo se pueden ajustar los parámetros correspondientes a `sigma`. Si el método de inicialización es `constant`, solo se pueden ajustar los parámetros correspondientes a `value`. Estas dependencias se enumeran en la siguiente tabla.
| Nombre del parámetro | Tipo de parámetro | Intervalos recomendados | Dependencia |
| --- | --- | --- | --- |
| bias\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==uniform |
| bias\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==normal |
| bias\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==constant |
| bias\$1lr | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Ninguno |
| bias\$1wd | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Ninguno |
| epoch | IntegerParameterRange | MinValue: 1, 1000 MaxValue | Ninguno |
| factors\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==uniform |
| factors\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==normal |
| factors\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==constant |
| factors\$1lr | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Ninguno |
| factors\$1wd | ContinuousParameterRange | MinValue: 1e-8, 512] MaxValue | Ninguno |
| linear\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==uniform |
| linear\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==normal |
| linear\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==constant |
| linear\$1lr | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Ninguno |
| linear\$1wd | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Ninguno |
| mini\$1batch\$1size | IntegerParameterRange | MinValue: 100, 10000 MaxValue | Ninguno |
# Formatos de respuesta de máquinas de factorización
Amazon SageMaker AI proporciona varios formatos de respuesta para obtener inferencias del modelo de máquinas de factorización, como JSON, JSONLINES y RECORDIO, con estructuras específicas para tareas de clasificación binaria y regresión.
## Formato de respuesta JSON
Clasificación binaria
```
let response = {
"predictions": [
{
"score": 0.4,
"predicted_label": 0
}
]
}
```
Regresión
```
let response = {
"predictions": [
{
"score": 0.4
}
]
}
```
## Formato de respuesta JSONLINES
Clasificación binaria
```
{"score": 0.4, "predicted_label": 0}
```
Regresión
```
{"score": 0.4}
```
## Formato de respuesta RECORDIO
Clasificación binaria
```
[
Record = {
features = {},
label = {
'score’: {
keys: [],
values: [0.4] # float32
},
'predicted_label': {
keys: [],
values: [0.0] # float32
}
}
}
]
```
Regresión
```
[
Record = {
features = {},
label = {
'score’: {
keys: [],
values: [0.4] # float32
}
}
}
]
```
# Algoritmo k vecinos más próximos (k-NN) (K-Nearest Neighbors)
El algoritmo k-NN (k-NN) de Amazon SageMaker AI es un algoritmo basado en índices. Utiliza un método no paramétrico para la clasificación o regresión. Para los problemas de clasificación, el algoritmo consulta los *k* puntos que están más próximos al punto de muestra y devuelve la etiqueta que se utiliza con más frecuencia de su clase como la etiqueta predicha. Para los problemas de regresión, el algoritmo consulta los *k* puntos que están más próximos al punto de muestra y devuelve la media de sus valores característica como el valor predicho.
La capacitación con el algoritmo k-NN tiene tres pasos: muestreo, reducción de dimensión y construcción de índice. El muestreo reduce el tamaño del conjunto de datos inicial para que se adapte en la memoria. Para la reducción de dimensión, el algoritmo disminuye la dimensión característica de los datos para reducir la huella del modelo k-NN en memoria y latencia de inferencia. Ofrecemos dos métodos de reducción de dimensión: proyección aleatoria y la transformación rápida de Johnson-Lindenstrauss. Por norma general, debe utilizar reducción de dimensión para conjuntos de datos de alto nivel dimensional (d > 1000) para evitar la "maldición de dimensionalidad" que perturba el análisis estadístico de datos que se vuelve disperso cuando aumenta la dimensionalidad. El objetivo principal de la capacitación de k-NN es construir el índice. El índice permite búsquedas eficientes de distancias entre puntos cuyos valores o etiquetas de clase todavía no se han determinado y los k puntos más próximos a utilizar para inferencia.
**Topics**
+ [Interfaz de entrada/salida para el Algoritmo k-NN](#kNN-input_output)
+ [Cuadernos de ejemplo de k-NN](#kNN-sample-notebooks)
+ [¿Cómo funciona el Algoritmo k-NN?](kNN_how-it-works.md)
+ [Recomendación de la instancia EC2 para algoritmo k-NN](#kNN-instances)
+ [Hiperparámetros k-NN](kNN_hyperparameters.md)
+ [Ajustar un modelo k-NN](kNN-tuning.md)
+ [Formatos de datos para entrada de entrenamiento de k-NN](kNN-in-formats.md)
+ [Formatos de respuesta y solicitud k-NN](kNN-inference-formats.md)
## Interfaz de entrada/salida para el Algoritmo k-NN
SageMaker AI k-NN admite canales de datos de entrenamiento y prueba.
+ Utilice un *canal de capacitación* para los datos que desee muestrear y construir en el índice k-NN.
+ Utilice un *canal de prueba* para emitir puntuaciones en archivos de registro. Las puntuaciones se enumeran como una línea por mini-lote: precisión para `classifier`, error cuadrático medio (mse) `regressor` para puntuación.
Para capacitación de entradas, k-NN admite formatos de datos `text/csv` y `application/x-recordio-protobuf`. Para tipo de entrada `text/csv`, las primeras columnas `label_size` se interpretan como el vector de etiqueta de esa fila. Puede usar el modo de archivo o el modo de canalización para capacitar modelos con datos con formato `recordIO-wrapped-protobuf` o `CSV`.
Para entradas de inferencia, k-NN admite los formatos de datos `application/json`, `application/x-recordio-protobuf` y `text/csv`. El formato `text/csv` acepta un `label_size` y parámetro de codificación. Presupone que `label_size` tiene un valor de 0 y la codificación es UTF-8.
Para salidas de inferencia, k-NN admite los formatos de datos `application/json` y `application/x-recordio-protobuf`. Estos dos formatos de datos también son compatibles con el modo de salida detallado. En modo de salida detallado, la API proporciona los resultados de búsqueda con el vector de distancias ordenado de menor a mayor y los elementos correspondientes en el vector de las etiquetas.
Para transformar por lotes, k-NN admite el formato de datos `application/jsonlines` tanto para entrada como para salida. Un ejemplo de entrada sería el siguiente:
```
content-type: application/jsonlines
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```
Un ejemplo de salida sería el siguiente:
```
accept: application/jsonlines
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```
Para obtener más información acerca de formatos de archivo de entrada y salida, consulte [Formatos de datos para entrada de entrenamiento de k-NN](kNN-in-formats.md) para la capacitación, [Formatos de respuesta y solicitud k-NN](kNN-inference-formats.md) para inferencia y [Cuadernos de ejemplo de k-NN](#kNN-sample-notebooks).
## Cuadernos de ejemplo de k-NN
Para ver un ejemplo de cuaderno que utiliza el algoritmo K-Nearest Neighbor Covertype de SageMaker IA para predecir los tipos de cobertura silvestre a partir de datos geológicos y de los servicios forestales, consulte el tipo de cobertura del vecino más cercano [K-Nearest](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/k_nearest_neighbors_covtype/k_nearest_neighbors_covtype.html) Neighbor.
Usa una instancia de Jupyter notebook para ejecutar el ejemplo en IA. SageMaker Para obtener información sobre cómo crear y abrir una instancia de Jupyter notebook 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 cuadernos de ejemplos de SageMaker IA. Encuentra los blocs de notas de vecino k más próximo en la sección **Introducción a los algoritmos de Amazon**. Para abrir un cuaderno, haga clic en la pestaña **Usar** y seleccione **Crear copia**.
# ¿Cómo funciona el Algoritmo k-NN?
El algoritmo k-NN (k-NN) de Amazon SageMaker AI sigue un proceso de entrenamiento de varios pasos que incluye el muestreo de los datos de entrada, la reducción de dimensiones y la creación de un índice. A continuación, los datos indexados se utilizan durante la inferencia para encontrar de manera eficiente los k vecinos más cercanos de un punto de datos determinado y realizar predicciones basadas en las etiquetas o valores vecinos.
## Paso 1:Muestreado
Para especificar el número total de puntos de datos que se van a muestrear a partir de conjuntos de datos de capacitación, utilice el parámetro `sample_size`. Por ejemplo, si el conjunto de datos inicial tiene 1000 puntos de datos y el `sample_size` se fija en 100, donde el número total de instancias es 2, cada trabajador debería muestrear 50 puntos. Se recopilaría un conjunto total de 100 puntos de datos. El muestreo se ejecuta en tiempo lineal con respecto a la cantidad de puntos de datos.
## Paso 2: Realizar reducción de dimensión
La implementación actual del algoritmo k-NN tiene dos métodos de reducción de dimensión. Especifique el método en el hiperparámetro `dimension_reduction_type`. El método `sign` especifica una proyección aleatoria, que utiliza una proyección lineal con una matriz de señales aleatorias y el método `fjlt` especifica una transformación rápida de Johnson-Lindenstrauss, un método basado en la transformación de Fourier. Ambos métodos conservan las distancias de producto interno y L2. El método `fjlt` debe utilizarse cuando la dimensión de destino es grande y tiene un mejor rendimiento con inferencia de CPU. Los métodos difieren en su complejidad informática. El método `sign` requiere tiempo O(ndk) para reducir la dimensión de un lote de n puntos de dimensión d en una dimensión de destino k. El método `fjlt` requiere tiempo O(nd log (d)), pero las constantes implicadas son mayores. El uso de reducción de dimensión introduce ruido en los datos y este ruido puede reducir la precisión de la predicción.
## Paso 3: Construir un índice
Durante la inferencia, el algoritmo consulta el índice en busca de un punto de k-nearest-neighbors muestra. En función de las referencias a los puntos, el algoritmo hace la clasificación o predicción de regresión. Hace la predicción en función de las etiquetas de clase o valores proporcionados. k-NN ofrece tres tipos diferentes de índices: un índice plano, un índice invertido y un índice invertido con cuantificación del producto. Especifique el tipo con el parámetro `index_type`.
## Serializar el modelo
Cuando el algoritmo k-NN termina la capacitación, serializa tres archivos para preparar para realizar inferencias.
+ model\$1algo-1: Contiene el índice serializado para computar los vecinos más próximos.
+ model\$1algo-1.labels: Contiene etiquetas serializadas (formato binario np.float32) para computar la etiqueta predicha a partir del resultado de la consulta del índice.
+ model\$1algo-1.json: Contiene el modelo con formato JSON que almacena los metadatos `k` e `predictor_type` hiperparámetros de capacitación para inferencia junto con otros estados pertinentes.
Con la implementación actual de k-NN, puede modificar el archivo de metadatos para cambiar el modo en que se calculan las predicciones. Por ejemplo, puede cambiar `k` a 10 o cambiar `predictor_type` a *regresor*.
```
{
"k": 5,
"predictor_type": "classifier",
"dimension_reduction": {"type": "sign", "seed": 3, "target_dim": 10, "input_dim": 20},
"normalize": False,
"version": "1.0"
}
```
## Recomendación de la instancia EC2 para algoritmo k-NN
Recomendamos entrenar en una instancia de CPU (como ml.m5.2xlarge) o en una instancia de GPU. El algoritmo k-NN admite las familias de instancias de GPU P2, P3, G4dn y G5 para el entrenamiento y la inferencia.
Las solicitudes de inferencia CPUs suelen tener una latencia media inferior a la de las solicitudes, GPUs ya que la CPU-to-GPU comunicación se ve afectada cuando se utiliza hardware de GPU. Sin embargo, GPUs suelen tener un rendimiento superior para lotes más grandes.
# Hiperparámetros k-NN
En la siguiente tabla se enumeran los hiperparámetros que puede configurar para el algoritmo k-NN (k-NN) de Amazon SageMaker AI.
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| feature\$1dim | El número de características en los datos de entrada. **Obligatorio** Valores válidos: número entero positivo. |
| k | El número de vecinos más próximos. **Obligatorio** Valores válidos: número entero positivo |
| predictor\$1type | El tipo de inferencia a usar en las etiquetas de datos. **Obligatorio** Valores válidos: *clasificador* para clasificación o *regresor* para regresión. |
| sample\$1size | El número de puntos de datos que se muestrearán a partir del conjunto de datos de capacitación. **Obligatorio** Valores válidos: número entero positivo |
| dimension\$1reduction\$1target | La dimensión de destino a la que reducir. **Obligatorio** cuando se especifica el parámetro `dimension_reduction_type`. Valores válidos: número entero positivo no superior a 0 y menor a `feature_dim`. |
| dimension\$1reduction\$1type | El tipo de método de reducción de dimensión. **Opcional** Valores válidos: *señal* para proyección aleatoria o *fjlt* para la transformación rápida de Johnson-Lindenstrauss. Valor predeterminado: Sin reducción de dimensión |
| faiss\$1index\$1ivf\$1nlists | *El número de centroides que se van a construir en el índice cuando es faiss. `index_type` *IVFFlat*o faiss.ivfpq.* **Opcional** Valores válidos: número entero positivo Valor predeterminado: *automático*, que se resuelve como `sqrt(sample_size)`. |
| faiss\$1index\$1pq\$1m | El número de subcomponentes vectoriales a construir en el índice cuando `index_type` se fija en *faiss.IVFPQ*. La biblioteca FaceBook AI Similarity Search (FAISS) requiere que el valor de `faiss_index_pq_m` sea un divisor de la dimensión de datos. Si `faiss_index_pq_m` no es un divisor de la dimensión de datos, se incrementará la dimensión de datos al menor el número entero divisible por `faiss_index_pq_m`. Si no se aplica ninguna reducción de dimensión, el algoritmo añade un relleno de ceros. Si se aplica la reducción de dimensión, el algoritmo aumenta el valor del hiperparámetro `dimension_reduction_target`. **Opcional** Valores válidos: uno de los siguientes números enteros positivos: 1, 2, 3, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 96 |
| index\$1metric | La métrica para medir la distancia entre puntos al encontrar vecinos más próximos. Cuando se capacita con `index_type` establecido en `faiss.IVFPQ`, la distancia de `INNER_PRODUCT` y la similitud de `COSINE` no son compatibles. **Opcional** Valores válidos: *L2* para distancia euclidiana, *INNER\$1PRODUCT* para distancia de producto interior, *COSINE* para similitud de coseno. Valor predeterminado: *L2* |
| index\$1type | El tipo de índice. **Opcional** *Valores válidos: *FAISS.flat, faiss*. *IVFFlat*, faiss.ivfpq.* Valores predeterminados: *faiss.Flat* |
| mini\$1batch\$1size | El número de observaciones por minilote para el iterador de datos. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 5000 |
# Ajustar un modelo k-NN
El algoritmo SageMaker k-nearest neighbors de Amazon AI es un algoritmo supervisado. El algoritmo consume un conjunto de datos de prueba y emite una métrica sobre la precisión para una tarea de clasificación o sobre el error cuadrático medio para una tarea de regresión. Estas métricas de precisión comparan las predicciones del modelo para sus respectivas tareas con el dato real que proporcionan los datos de prueba empíricos. Para buscar el mejor modelo que notifica la mayor precisión o menor error en el conjunto de datos de prueba, ejecute un trabajo de ajuste de hiperparámetro para k-NN.
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 objetivo adecuada para la tarea de predicción del algoritmo. 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. Los hiperparámetros se utilizan únicamente para ayudar a calcular los parámetros del modelo y no se utilizan en el modelo capacitado para realizar predicciones.
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 k-NN
El algoritmo k vecinos más próximos calcula una de dos métricas en la siguiente tabla durante la capacitación en función del tipo de tarea especificado por el `predictor_type` hiperparámetro.
+ *clasificador* especifica una tarea de clasificación tarea y calcula `test:accuracy`
+ *clasificador* especifica una tarea de regresión y calcula `test:mse`.
Elija el valor `predictor_type` adecuado para el tipo de tarea empleado para calcular la métrica objetivo pertinente al ajustar un modelo.
| Nombre de métrica | Description (Descripción) | Dirección de optimización |
| --- | --- | --- |
| test:accuracy | Cuando `predictor_type` se establece en *clasificador*, k-NN compara la etiqueta predicha, en función de la media de las etiquetas de los k vecinos más próximos con el dato real que se proporciona en los datos de canal de prueba. La precisión notificada oscila entre 0,0 (0 %) y 1,0 (100 %). | Maximizar |
| test:mse | Cuando `predictor_type` se establece en *regresor*, k-NN compara la etiqueta predicha, en función de la media de las etiquetas de los k vecinos más próximos con la etiqueta real que se proporciona en los datos de canal de prueba. El error cuadrático medio se calcula comparando las dos etiquetas. | Minimizar |
## Hiperparámetros k-NN ajustables
Ajuste el modelo de vecino más cercano k de Amazon SageMaker AI con los siguientes hiperparámetros.
| Nombre del parámetro | Tipo de parámetro | Intervalos recomendados |
| --- | --- | --- |
| k | IntegerParameterRanges | MinValue: 1, 1024 MaxValue |
| sample\$1size | IntegerParameterRanges | MinValue: 256, MaxValue 20000000 |
# Formatos de datos para entrada de entrenamiento de k-NN
Todos los algoritmos integrados de Amazon SageMaker AI cumplen con los formatos de entrenamiento de entrada comunes descritos en [Formatos de datos comunes: entrenamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-training.html). Este tema contiene una lista de los formatos de entrada disponibles para el k-nearest-neighbor algoritmo de SageMaker IA.
## Formato de los datos CSV
content-type: text/csv; label\$1size=1
```
4,1.2,1.3,9.6,20.3
```
Las primeras columnas `label_size` se interpretan como el vector de etiqueta para esa fila.
## Formato de datos RECORDIO
tipo de contenido: aplicación/ x-recordio-protobuf
```
[
Record = {
features = {
'values': {
values: [1.2, 1.3, 9.6, 20.3] # float32
}
},
label = {
'values': {
values: [4] # float32
}
}
}
]
}
```
# Formatos de respuesta y solicitud k-NN
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 de SageMaker IA k-nearest-neighbor.
## ENTRADA: Formato de solicitud CSV
content-type: text/csv
```
1.2,1.3,9.6,20.3
```
Esta acepta un `label_size` o parámetro de codificación. Presupone que `label_size` tiene un valor de 0 y la codificación es UTF-8.
## ENTRADA: Formato de solicitud JSON
content-type: application/json
```
{
"instances": [
{"data": {"features": {"values": [-3, -1, -4, 2]}}},
{"features": [3.0, 0.1, 0.04, 0.002]}]
}
```
## ENTRADA: Formato de solicitud JSONLINES
content-type: application/jsonlines
```
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```
## ENTRADA: Formato de solicitud RECORDIO
tipo de contenido: aplicación/ x-recordio-protobuf
```
[
Record = {
features = {
'values': {
values: [-3, -1, -4, 2] # float32
}
},
label = {}
},
Record = {
features = {
'values': {
values: [3.0, 0.1, 0.04, 0.002] # float32
}
},
label = {}
},
]
```
## SALIDA: Formato de respuesta JSON
accept: application/json
```
{
"predictions": [
{"predicted_label": 0.0},
{"predicted_label": 2.0}
]
}
```
## SALIDA: Formato de respuesta JSONLINES
accept: application/jsonlines
```
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```
## SALIDA: Formato de respuesta VERBOSE JSON
En modo de salida detallado, la API proporciona los resultados de búsqueda con el vector de distancias ordenado de menor a mayor, con los elementos correspondientes en el vector de las etiquetas. En este ejemplo, k se fija en 3.
accept: application/json; verbose=true
```
{
"predictions": [
{
"predicted_label": 0.0,
"distances": [3.11792408, 3.89746071, 6.32548437],
"labels": [0.0, 1.0, 0.0]
},
{
"predicted_label": 2.0,
"distances": [1.08470316, 3.04917915, 5.25393973],
"labels": [2.0, 2.0, 0.0]
}
]
}
```
## SALIDA: Formato de respuesta RECORDIO-PROTOBUF
tipo de contenido: aplicación/ x-recordio-protobuf
```
[
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
}
}
},
Record = {
features = {},
label = {
'predicted_label': {
values: [2.0] # float32
}
}
}
]
```
## SALIDA: Formato de respuesta VERBOSE RECORDIO-PROTOBUF
En modo de salida detallado, la API proporciona los resultados de búsqueda con el vector de distancias ordenado de menor a mayor, con los elementos correspondientes en el vector de las etiquetas. En este ejemplo, k se fija en 3.
aceptar: aplicación/; verbose=true x-recordio-protobuf
```
[
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
},
'distances': {
values: [3.11792408, 3.89746071, 6.32548437] # float32
},
'labels': {
values: [0.0, 1.0, 0.0] # float32
}
}
},
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
},
'distances': {
values: [1.08470316, 3.04917915, 5.25393973] # float32
},
'labels': {
values: [2.0, 2.0, 0.0] # float32
}
}
}
]
```
## SALIDA DE MUESTRA para el algoritmo k-NN
Para tareas regresor:
```
[06/08/2018 20:15:33 INFO 140026520049408] #test_score (algo-1) : ('mse', 0.013333333333333334)
```
Para tareas clasificador:
```
[06/08/2018 20:15:46 INFO 140285487171328] #test_score (algo-1) : ('accuracy', 0.98666666666666669)
```
# LightGBM
[LightGBM](https://lightgbm.readthedocs.io/en/latest/) es una implementación de código abierto popular y eficiente del algoritmo Gradient Boosting Decision Tree (GBDT). GBDT es un algoritmo de aprendizaje supervisado que intenta predecir adecuadamente una variable objetivo mediante la combinación de un conjunto de estimaciones a partir de un conjunto de modelos más simples y más débiles. LightGBM utiliza técnicas adicionales para mejorar significativamente la eficiencia y la escalabilidad de la GBDT convencional. Esta página incluye información sobre las recomendaciones de instancias de Amazon EC2 y cuadernos de muestra para LightGBM.
# Cómo utilizar SageMaker AI LightGBM
Puedes usar LightGBM como un algoritmo integrado de Amazon SageMaker AI. La siguiente sección describe cómo usar LightGBM con el SDK de SageMaker Python. Para obtener información sobre cómo usar LightGBM desde la interfaz de usuario clásica de Amazon SageMaker Studio, consulte. [SageMaker JumpStart modelos preentrenados](studio-jumpstart.md)
+ **Utilizar LightGBM como algoritmo integrado**
Utilice el algoritmo integrado LightGBM para crear un contenedor de entrenamiento de LightGBM tal como se muestra en el ejemplo de código siguiente. Puede detectar automáticamente el URI de la imagen del algoritmo integrado de LightGBM mediante la API de SageMaker IA (o la `image_uris.retrieve` `get_image_uri` API si utiliza la versión 2 del [SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable)).
Tras especificar el URI de la imagen de LightGBM, puede utilizar el contenedor LightGBM para crear un estimador mediante la API SageMaker AI Estimator e iniciar un trabajo de formación. El algoritmo integrado LightGBM se ejecuta en modo script, pero el script de entrenamiento se proporciona automáticamente y no es necesario reemplazarlo. Si tiene una amplia experiencia en el uso del modo script para crear un trabajo de formación, puede incorporar sus propios guiones de SageMaker entrenamiento de LightGBM.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "lightgbm-classification-model", "*", "training"
training_instance_type = "ml.m5.xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_multiclass/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"num_boost_round"
] = "500"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_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, # for distributed training, specify an instance_count greater than 1
instance_type=training_instance_type,
max_run=360000,
hyperparameters=hyperparameters,
output_path=s3_output_location
)
# Launch a SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"train": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Para obtener más información acerca de cómo configurar LightGBM como un algoritmo integrado, consulte los siguientes ejemplos de cuadernos.
+ [Clasificación tabular con Amazon SageMaker AI LightGBM y algoritmo CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.ipynb)
+ [Regresión tabular con Amazon SageMaker AI LightGBM y algoritmo CatBoost ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.ipynb)
# Interfaz de entrada/salida para el algoritmo LightGBM
La potenciación de gradientes funciona en los datos tabulares, con las filas que representan observaciones, una columna que representa la variable de destino o la etiqueta, y las columnas restantes que representan las características.
La implementación de SageMaker inteligencia artificial de LightGBM admite CSV para el entrenamiento y la inferencia:
+ *Para el **entrenamiento ContentType**, las entradas válidas deben ser text/csv.*
+ *Para la **inferencia ContentType**, las entradas válidas deben ser text/csv.*
**nota**
Para la capacitación de CSV, el algoritmo asume la variable de destino en la primera columna y ese CSV no dispone de un registro de encabezado.
Para la inferencia de CSV, el algoritmo asume que la entrada de CSV no dispone de la columna de etiqueta.
**Formato de entrada para los datos de entrenamiento, los datos de validación y las características categóricas**
Tenga cuidado con el formato de los datos de entrenamiento que introducirá en el modelo LightGBM. Debe proporcionar la ruta a un bucket de Amazon S3 que contenga los datos de entrenamiento y de validación. También puede incluir una lista de características categóricas. Utilice los canales `train` y `validation` para proporcionar los datos de entrada. o utilice solo el canal `train` si lo prefiere.
**nota**
Tanto `train` como `training` son nombres de canales válidos para el entrenamiento con LightGBM.
**Uso de ambos canales (`train` y `validation`)**
Puede proporcionar los datos de entrada mediante dos rutas S3, una para el canal `train` y otra para el canal `validation`. Cada ruta S3 puede ser un prefijo S3 que apunte a uno o más archivos CSV, o una ruta S3 completa que apunte a un archivo CSV específico. Las variables de destino deben estar en la primera columna del archivo CSV. Las variables predictoras (características) deben estar en las columnas restantes. Si se proporcionan varios archivos CSV para los canales `train` o `validation`, el algoritmo LightGBM concatena los archivos. Los datos de validación se utilizan para calcular una puntuación de validación al final de cada iteración de potenciación. Hay una interrupción anticipada cuando la puntuación de validación deja de mejorar.
Si los predictores incluyen características categóricas, puede proporcionar un archivo JSON con el nombre `categorical_index.json` en la misma ubicación que los archivos de datos de entrenamiento. Si proporciona un archivo JSON para las características categóricas, el canal `train` debe apuntar a un prefijo S3, y no a un archivo CSV específico. Este archivo debe contener un diccionario de Python donde la clave sea la cadena `"cat_index_list"` y el valor sea una lista de enteros únicos. Cada número entero de la lista de valores debe indicar el índice de columnas de las características categóricas correspondientes en el archivo CSV de datos de entrenamiento. Cada valor debe ser un entero positivo (mayor de cero, ya que cero representa el valor objetivo), menor que el `Int32.MaxValue` (2147483647) y menor que el número total de columnas. Solo debe haber un archivo JSON de índice categórico.
**Uso del canal `train` exclusivamente**
También puede proporcionar sus datos de entrada mediante una única ruta S3 para el canal `train`. Esta ruta S3 debe apuntar a un directorio con un subdirectorio denominado `train/` que contenga uno o más archivos CSV. Si lo desea, puede incluir otro subdirectorio en la misma ubicación, denominado `validation/`, que también tenga uno o más archivos CSV. Si no se proporcionan los datos de validación, se toma una muestra aleatoria del 20 % de los datos de entrenamiento para que ejerzan como datos de validación. Si los predictores contienen características categóricas, puede proporcionar un archivo JSON con el nombre `categorical_index.json` en la misma ubicación que los subdirectorios de datos.
**nota**
En el modo de entrada de entrenamiento de CSV, la memoria total disponible para el algoritmo (el recuento de instancias multiplicado por la memoria disponible en `InstanceType`) debe poder contener el conjunto de datos de entrenamiento.
SageMaker AI LightGBM usa el módulo Joblib de Python para serializar o deserializar el modelo, que se puede usar para guardar o cargar el modelo.
**Para usar un modelo entrenado con AI LightGBM con el módulo SageMaker JobLib**
+ Utilice el siguiente código de Python:
```
import joblib
import tarfile
t = tarfile.open('model.tar.gz', 'r:gz')
t.extractall()
model = joblib.load(model_file_path)
# prediction with test data
# dtest should be a pandas DataFrame with column names feature_0, feature_1, ..., feature_d
pred = model.predict(dtest)
```
## Recomendación de instancias de Amazon EC2 para el algoritmo LightGBM
SageMaker Actualmente, AI LightGBM admite el entrenamiento de CPU en una o varias instancias. Para el entrenamiento de CPU en varias instancias (entrenamiento distribuido), especifique un valor `instance_count` mayor que 1 cuando defina su estimador. Para obtener más información sobre la formación distribuida con LightGBM, consulte Formación [distribuida de Amazon SageMaker AI LightGBM](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html) con Dask.
LightGBM es un algoritmo de vinculación de memoria (a diferencia de la vinculación de computación). Por lo tanto, una instancia de computación de uso general (por ejemplo, M5) es una opción mejor que una instancia optimizada para la computación (por ejemplo, C5). Además, recomendamos que disponga de suficiente memoria en total en las instancias seleccionadas para almacenar los datos de capacitación.
## Ejemplos de cuadernos LightGBM
En la siguiente tabla se describen varios ejemplos de libretas que abordan distintos casos de uso del algoritmo LightGBM de Amazon SageMaker AI.
****
| **Título del cuaderno** | **Descripción** |
| --- | --- |
| [Clasificación tabular con Amazon SageMaker AI LightGBM y algoritmo CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Classification_LightGBM_CatBoost.html) | Este cuaderno muestra el uso del algoritmo Amazon SageMaker AI LightGBM para entrenar y alojar un modelo de clasificación tabular. |
| [Regresión tabular con Amazon SageMaker AI LightGBM y algoritmo CatBoost ](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/lightgbm_catboost_tabular/Amazon_Tabular_Regression_LightGBM_CatBoost.html) | En este cuaderno se muestra el uso del algoritmo LightGBM de Amazon SageMaker AI para entrenar y alojar un modelo de regresión tabular. |
| [Capacitación distribuida de Amazon SageMaker AI LightGBM con Dask](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/sagemaker_lightgbm_distributed_training_dask/sagemaker-lightgbm-distributed-training-dask.html) | Este cuaderno muestra el entrenamiento distribuido con el algoritmo LightGBM de Amazon SageMaker AI mediante el marco Dask. |
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 una instancia de bloc de notas y abrirla, selecciona 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**.
# Funcionamiento de LightGBM
LightGBM implementa un algoritmo convencional de árbol de decisiones con potenciación por gradiente (GBDT), con la adición de dos técnicas novedosas: el muestreo unilateral basado en gradientes (GOSS) y el agrupamiento de características exclusivas (EFB). Estas técnicas están diseñadas para mejorar considerablemente la eficiencia y la escalabilidad del GBDT.
LightGBM tiene un gran rendimiento en competiciones de machine learning, ya que puede gestionar con solvencia distintos tipos de datos, relaciones y distribuciones, así como la amplia variedad de hiperparámetros que se pueden ajustar. Puede usar LightGBM para problemas de regresión, de clasificación (binaria y multiclase) y de ranking.
Para obtener más información sobre la potenciación por gradiente, consulte [Cómo funciona el XGBoost algoritmo de SageMaker IA](xgboost-HowItWorks.md). Para obtener información detallada sobre las técnicas adicionales de GOSS y EFB utilizadas en el método LightGBM, consulte *[LightGBM: A Highly Efficient Gradient Boosting Decision Tree](https://proceedings.neurips.cc/paper/2017/file/6449f44a102fde848669bdd9eb6b76fa-Paper.pdf)*.
# Hiperparámetros de LightGBM
La siguiente tabla contiene el subconjunto de hiperparámetros que se requieren o se utilizan con más frecuencia para el algoritmo LightGBM de Amazon SageMaker AI. Los usuarios establecen estos parámetros para facilitar la estimación de los parámetros del modelo a partir de los datos. [El algoritmo SageMaker AI LightGBM es una implementación del paquete LightGBM de código abierto.](https://github.com/microsoft/LightGBM)
**nota**
Los hiperparámetros predeterminados se basan en conjuntos de datos de ejemplo de [Ejemplos de cuadernos LightGBM](lightgbm.md#lightgbm-sample-notebooks).
De forma predeterminada, el algoritmo SageMaker AI LightGBM elige automáticamente una métrica de evaluación y una función objetivo en función del tipo de problema de clasificación. El algoritmo LightGBM detecta el tipo de problema de clasificación a partir del número de etiquetas en los datos. Para los problemas de regresión, la métrica de evaluación es la raíz del error cuadrático medio y la función objetivo es la pérdida L2. Para los problemas de clasificación binaria, la métrica de evaluación y la función objetivo son la entropía cruzada binaria. Para los problemas de clasificación multiclase, la métrica de evaluación es la entropía cruzada multiclase y la función objetivo es softmax. Puede usar el hiperparámetro `metric` para cambiar la métrica de evaluación predeterminada. Consulte la siguiente tabla para obtener más información sobre los hiperparámetros en LightGBM, lo que incluye las descripciones, los valores válidos y los valores predeterminados.
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| num\$1boost\$1round | El número máximo de iteraciones de potenciación. **Nota:** Internamente, LightGBM construye árboles `num_class * num_boost_round` para problemas de clasificación multiclase. Valores válidos: entero positivo. Valor predeterminado: `100`. |
| early\$1stopping\$1rounds | El entrenamiento se detendrá si una métrica de un punto de datos de validación no mejora en la última ronda `early_stopping_rounds`. Si `early_stopping_rounds` es inferior o igual a cero, se omite este hiperparámetro. Valores válidos: número entero Valor predeterminado: `10`. |
| metric | Métricas de evaluación de los datos de validación. Si `metric` se establece en el valor `"auto"` predeterminado, el algoritmo elige automáticamente una métrica de evaluación en función del tipo de problema de clasificación: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/lightgbm-hyperparameters.html) Valores válidos: cadena, valores `"auto"`, `"rmse"`, `"l1"`, `"l2"`, `"huber"`, `"fair"`, `"binary_logloss"`, `"binary_error"`, `"auc"`, `"average_precision"`, `"multi_logloss"`, `"multi_error"`, `"auc_mu"` o `"cross_entropy"`. Valor predeterminado: `"auto"`. |
| learning\$1rate | La velocidad a la que se actualizan los pesos del modelo después de pasar por cada lote de ejemplos de entrenamiento. Valores válidos: flotante, rango (`0.0`, `1.0`). Valor predeterminado: `0.1`. |
| num\$1leaves | El número máximo de hojas de un árbol. Valores válidos: entero, rango (`1`, `131072`). Valor predeterminado: `64`. |
| feature\$1fraction | Un subconjunto de características que se seleccionarán en cada iteración (árbol). Debe ser menos de 1,0. Valores válidos: flotante, rango (`0.0`, `1.0`). Valor predeterminado: `0.9`. |
| bagging\$1fraction | Un subconjunto de características similar a `feature_fraction`, pero `bagging_fraction` selecciona aleatoriamente una parte de los datos sin necesidad de volver a muestrearlos. Valores válidos: flotante, rango (`0.0`, `1.0`). Valor predeterminado: `0.9`. |
| bagging\$1freq | La frecuencia con la que se realiza el bagging. En cada iteración de `bagging_freq`, LightGBM selecciona aleatoriamente un porcentaje de los datos para usarlos en la siguiente iteración `bagging_freq`. Este porcentaje lo determina el hiperparámetro `bagging_fraction`. Si `bagging_freq` es cero, se desactiva el bagging. Valores válidos: número entero no negativo. Valor predeterminado: `1`. |
| max\$1depth | La profundidad máxima de un modelo de árbol. Se utiliza para tratar el sobreajuste cuando la cantidad de datos es pequeña. Si `max_depth` es menor o igual a cero, significa que no hay límite para la profundidad máxima. Valores válidos: número entero Valor predeterminado: `6`. |
| min\$1data\$1in\$1leaf | La cantidad mínima de datos en una hoja. Se puede utilizar para hacer frente al sobreajuste. Valores válidos: número entero no negativo. Valor predeterminado: `3`. |
| max\$1delta\$1step | Se usa para limitar la producción máxima de hojas de árboles. Si `max_delta_step` es inferior o igual a 0, no hay ninguna restricción. La salida máxima final de hojas es `learning_rate * max_delta_step`. Valores válidos: número flotante Valor predeterminado: `0.0`. |
| lambda\$1l1 | Regularización L1. Valores válidos: número flotante no negativo. Valor predeterminado: `0.0`. |
| lambda\$1l2 | Regularización L2. Valores válidos: número flotante no negativo. Valor predeterminado: `0.0`. |
| boosting | Tipo de potenciación Valores válidos: cadena (`"gbdt"`, `"rf"`, `"dart"` o `"goss"`). Valor predeterminado: `"gbdt"`. |
| min\$1gain\$1to\$1split | La ganancia mínima para realizar una división. Se puede utilizar para acelerar el entrenamiento. Valores válidos: número flotante no negativo. Valor predeterminado: `0.0`. |
| scale\$1pos\$1weight | La ponderación de las etiquetas con clase positiva. Se usa solo para tareas de clasificación binaria. `scale_pos_weight` no se puede usar si `is_unbalance` está establecido en `"True"`. Valores válidos: número flotante positivo. Valor predeterminado: `1.0`. |
| tree\$1learner | Tipo de aprendiz en árbol. Valores válidos: cadena (`"serial"`, `"feature"`, `"data"` o `"voting"`). Valor predeterminado: `"serial"`. |
| feature\$1fraction\$1bynode | Seleccione un subconjunto de características aleatorias en cada nodo del árbol. Por ejemplo, si `feature_fraction_bynode` es `0.8`, se selecciona el 80 % de las características. Se puede utilizar para hacer frente al sobreajuste. Valores válidos: entero, rango [`0.0`, `1.0`]. Valor predeterminado: `1.0`. |
| is\$1unbalance | Se establece en `"True"` si los datos de entrenamiento están desequilibrados. Se usa solo para tareas de clasificación binaria. `is_unbalance` no se puede usar con `scale_pos_weight`. Valores válidos: cadena (`"True"` o `"False"`). Valor predeterminado: `"False"`. |
| max\$1bin | El número máximo de contenedores utilizados para los valores de las características. de buckets. Un número reducido de contenedores puede reducir la precisión del entrenamiento, pero puede aumentar el rendimiento general. Se puede utilizar para hacer frente al sobreajuste. Valores válidos: entero, rango (1, ∞). Valor predeterminado: `255`. |
| tweedie\$1variance\$1power | Controla la varianza de la distribución de Tweedie. Colóquelo más cerca de `2.0` para cambiar hacia una distribución gamma. Colóquelo más cerca de `1.0` para cambiar hacia una distribución Poisson. Se usa solo para tareas de regresión. Valores válidos: flotante, con el rango [`1.0`, `2.0`]. Valor predeterminado: `1.5`. |
| num\$1threads | Número de subprocesos paralelos utilizados para ejecutar LightGBM. El valor 0 indica el número predeterminado de subprocesos en OpenMP. Valores válidos: número entero no negativo. Valor predeterminado: `0`. |
| verbosity | La verbosidad de los mensajes de impresión. Si `verbosity` es inferior a `0`, los mensajes de impresión solo muestran errores graves. Si `verbosity` está configurado en `0`, los mensajes de impresión incluyen errores y advertencias. Si `verbosity` es `1`, los mensajes de impresión muestran más información. Un `verbosity` mayor a `1` muestra la mayor cantidad de información en los mensajes de impresión y se puede usar para depurar. Valores válidos: número entero Valor predeterminado: `1`. |
# Ajuste de un modelo LightGBM
El *ajuste de modelo automático*, también conocido como ajuste de hiperparámetros, encuentra la mejor versión de un modelo ejecutando distintas tareas que prueban una serie de hiperparámetros en los conjuntos de datos de validación y entrenamiento. El ajuste del modelo se centra en los siguientes hiperparámetros:
**nota**
La función objetivo de aprendizaje se asigna automáticamente en función del tipo de tarea de clasificación, que viene determinada por el número de enteros únicos de la columna de etiquetas. Para obtener más información, consulte [Hiperparámetros de LightGBM](lightgbm-hyperparameters.md).
+ Una función objetivo de aprendizaje que se debe optimizar durante el entrenamiento con modelos.
+ Una métrica de evaluación que se utiliza para evaluar el rendimiento del modelo durante la validación.
+ Un conjunto de hiperparámetros y un rango de valores para emplear al ajustar el modelo automáticamente.
El ajuste de modelo automático busca los hiperparámetros especificados con el objetivo de encontrar una combinación de valores que genere un modelo capaz de optimizar la métrica de evaluación seleccionada.
**nota**
El ajuste automático de modelos para LightGBM solo está disponible en Amazon SageMaker SDKs, no en la consola SageMaker AI.
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 de evaluación calculadas por el algoritmo LightGBM
El algoritmo SageMaker AI LightGBM calcula las siguientes métricas para utilizarlas en la validación del modelo. La métrica de evaluación se asigna automáticamente en función del tipo de tarea de clasificación, que viene determinada por el número de enteros únicos en la columna de etiqueta.
| Nombre de métrica | Description (Descripción) | Dirección de optimización | Patrón de expresiones regulares |
| --- | --- | --- | --- |
| rmse | raíz del error cuadrático medio | minimizar | "rmse: ([0-9\$1\$1.]\$1)" |
| l1 | error absoluto medio | minimizar | "l1: ([0-9\$1\$1.]\$1)" |
| l2 | error cuadrático medio | minimizar | "l2: ([0-9\$1\$1.]\$1)" |
| huber | pérdida de Huber | minimizar | "huber: ([0-9\$1\$1.]\$1)" |
| fair | pérdida justa | minimizar | "fair: ([0-9\$1\$1.]\$1)" |
| binary\$1logloss | entropía cruzada binaria | maximizar | "binary\$1logloss: ([0-9\$1\$1.]\$1)" |
| binary\$1error | error binario | minimizar | "binary\$1error: ([0-9\$1\$1.]\$1)" |
| auc | AUC | maximizar | "auc: ([0-9\$1\$1.]\$1)" |
| average\$1precision | puntuación de precisión media | maximizar | "average\$1precision: ([0-9\$1\$1.]\$1)" |
| multi\$1logloss | entropía cruzada multiclase | maximizar | "multi\$1logloss: ([0-9\$1\$1.]\$1)" |
| multi\$1error | puntuación de error multiclase | minimizar | "multi\$1error: ([0-9\$1\$1.]\$1)" |
| auc\$1mu | AUC-mu | maximizar | "auc\$1mu: ([0-9\$1\$1.]\$1)" |
| cross\$1entropy | entropía cruzada | minimizar | "cross\$1entropy: ([0-9\$1\$1.]\$1)" |
## Hiperparámetros de LightGBM ajustables
Ajuste el modelo LightGBM con los siguientes hiperparámetros. Los hiperparámetros que tienen el mayor efecto en la optimización de las métricas de evaluación de LightGBM son `learning_rate`, `num_leaves`, `feature_fraction`, `bagging_fraction`, `bagging_freq`, `max_depth` y `min_data_in_leaf`. Para obtener una lista de todos los hiperparámetros de LightGBM, consulte [Hiperparámetros de LightGBM](lightgbm-hyperparameters.md).
| Nombre del parámetro | Tipo de parámetro | Intervalos recomendados |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001,: 0,01 MaxValue |
| num\$1leaves | IntegerParameterRanges | MinValue: 10, MaxValue 10 |
| feature\$1fraction | ContinuousParameterRanges | MinValue: 0,1, MaxValue 1,0 |
| bagging\$1fraction | ContinuousParameterRanges | MinValue: 0,1, MaxValue 1,0 |
| bagging\$1freq | IntegerParameterRanges | MinValue: 0, MaxValue: 10 |
| max\$1depth | IntegerParameterRanges | MinValue: 15, MaxValue 10 |
| min\$1data\$1in\$1leaf | IntegerParameterRanges | MinValue: 10, MaxValue 20 |
# Algoritmo de aprendizaje lineal
*Los modelos lineales* son algoritmos de aprendizaje supervisados que se utilizan para resolver problemas de clasificación o de regresión. Para la entrada, se dan los ejemplos etiquetados de modelo (*x*, *y*). *x* es un vector de gran dimensión e *y* es una etiqueta numérica. Para problemas de clasificación binaria, la etiqueta debe ser 0 o 1. Para problemas de clasificación multiclase, las etiquetas deben ir desde 0 hasta `num_classes` - 1. Para los problemas de regresión, *y* es un número real. El algoritmo aprende una función lineal o una función de umbral lineal para problemas de clasificación, y mapea un vector *x* a una aproximación de la etiqueta *y*.
El algoritmo de aprendizaje lineal Amazon SageMaker AI proporciona una solución para los problemas de clasificación y regresión. Con el algoritmo de SageMaker IA, puede explorar simultáneamente diferentes objetivos de entrenamiento y elegir la mejor solución de un conjunto de validación. También puede explorar una gran cantidad de modelos y elegir el mejor. El mejor modelo optimiza uno de los siguientes:
+ Objetivos continuos, como, por ejemplo, un error cuadrático medio, una pérdida de entropía cruzada o un error absoluto.
+ Objetivos discretos adecuados para clasificación, como, por ejemplo, medida F1, precisión, exhaustividad o exactitud.
En comparación con los métodos que ofrecen una solución solo para objetivos continuos, el algoritmo de aprendizaje lineal de la SageMaker IA proporciona un aumento significativo de la velocidad en comparación con las técnicas ingenuas de optimización de hiperparámetros. También es más práctico.
El algoritmo de aprendizaje lineal requiere una matriz de datos, con filas que representan las observaciones y columnas que representan las dimensiones de las características. También requiere una columna adicional que contiene las etiquetas que coinciden con los puntos de datos. Como mínimo, el aprendizaje lineal de Amazon SageMaker AI requiere que especifique las ubicaciones de los datos de entrada y salida y el tipo de objetivo (clasificación o regresión) como argumentos. La dimensión de características es también obligatoria. Para obtener más información, consulte [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Puede especificar parámetros adicionales en el mapa de cadenas `HyperParameters` del cuerpo de la solicitud. Estos parámetros controlan el procedimiento de optimización o detalles específicos de la función objetivo que se capacita. Por ejemplo, el número de fechas de inicio, regularización y tipo de pérdida.
Si utiliza [Managed Spot Training](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html), el algoritmo de aprendizaje lineal admite el uso de [puntos de control para tomar una instantánea del estado del modelo](https://docs.aws.amazon.com/sagemaker/latest/dg/model-checkpoints.html).
**Topics**
+ [Interfaz de entrada/salida para el algoritmo de aprendizaje lineal](#ll-input_output)
+ [Recomendación de instancia EC2 para el algoritmo de aprendizaje lineal](#ll-instances)
+ [Cuaderno de muestra de aprendizaje lineal](#ll-sample-notebooks)
+ [Cómo funciona el aprendizaje lineal](ll_how-it-works.md)
+ [Hiperparámetros de aprendizaje lineal](ll_hyperparameters.md)
+ [Ajustar un modelo de aprendizaje lineal](linear-learner-tuning.md)
+ [Formatos de respuesta de aprendizaje lineal](LL-in-formats.md)
## Interfaz de entrada/salida para el algoritmo de aprendizaje lineal
El algoritmo de aprendizaje lineal de Amazon SageMaker AI admite tres canales de datos: formación, validación (opcional) y prueba (opcional). Si proporciona datos de validación, el `S3DataDistributionType` debe ser `FullyReplicated`. El algoritmo registra pérdida de validación en cada fecha de inicio y utiliza una muestra de los datos de validación para calibrar y seleccionar el mejor modelo. Si no proporciona datos de validación, el algoritmo utiliza una muestra de los datos de capacitación para calibrar y seleccionar el modelo. Si proporciona datos de prueba, los registros de algoritmos incluyen la puntuación de prueba para el modelo final.
**Para la capacitación**, el algoritmo de aprendizaje lineal admite tanto los formatos `recordIO-wrapped protobuf` como `CSV`. Para el tipo de entrada `application/x-recordio-protobuf`, solo se admiten los tensores Float32. Para el tipo de entrada `text/csv`, se presupone que la primera columna es la etiqueta, que es la variable de destino para la predicción. Puede usar el modo de archivo o el modo de canalización para capacitar modelos de aprendizaje lineal con datos con formato `recordIO-wrapped-protobuf` o `CSV`.
**Para la inferencia**, el algoritmo de aprendizaje lineal admite los formatos `application/json`, `application/x-recordio-protobuf` y `text/csv`. Al realizar predicciones sobre nuevos datos, el formato de la respuesta depende del tipo de modelo. **Para la regresión** (`predictor_type='regressor'`), la `score` es la predicción producida por el modelo. **Para la clasificación** (`predictor_type='binary_classifier'` o `predictor_type='multiclass_classifier'`), el modelo devuelve una `score` y también una `predicted_label`. La `predicted_label` es la clase prevista por el modelo y la `score` mide la fuerza de esa predicción.
+ **Para la clasificación binaria**, `predicted_label` es `0` o `1`, y `score` es un único número de punto flotante que indica en qué medida el algoritmo cree que la etiqueta debe ser 1.
+ **Para la clasificación multiclase**, la `predicted_class` será un número entero de `0` a `num_classes-1`, y la `score` será una lista de un número de punto flotante por clase.
Para interpretar la `score` en problemas de clasificación, tiene que tener en cuenta la función de pérdida utilizada. Si el valor del hiperparámetro `loss` es `logistic` para la clasificación binaria o `softmax_loss` para la clasificación multiclase, entonces la `score` se puede interpretar como la probabilidad de la clase correspondiente. Estos son los valores de pérdida utilizados por el de aprendizaje lineal cuando el valor `loss` es el valor predeterminado `auto`. Pero si la pérdida se establece en `hinge_loss`, entonces la puntuación no puede interpretarse como una probabilidad. Esto se debe a que la pérdida de bisagra corresponde a un Support Vector Classifier, que no produce cálculos de probabilidad.
Para obtener más información acerca de los formatos de archivo de entrada y salida, consulte [Formatos de respuesta de aprendizaje lineal](LL-in-formats.md). Para obtener más información acerca de los formatos de inferencia, consulte [Cuaderno de muestra de aprendizaje lineal](#ll-sample-notebooks).
## Recomendación de instancia EC2 para el algoritmo de aprendizaje lineal
El algoritmo de aprendizaje lineal admite instancias de CPU y GPU para el entrenamiento y la inferencia. En el caso de la GPU, el algoritmo de aprendizaje lineal admite las familias de GPU P2, P3, G4dn y G5.
Durante las pruebas, no hemos encontrado pruebas sustanciales de que las instancias multi-GPU sean más rápidas que las instancias con GPU única. Los resultados pueden variar, en función de su caso de uso específico.
## Cuaderno de muestra de aprendizaje lineal
En la siguiente tabla se describen varios ejemplos de cuadernos que abordan diferentes casos de uso del algoritmo de aprendizaje lineal de Amazon SageMaker AI.
| **Título del cuaderno** | **Descripción** |
| --- | --- |
| [An Introduction with the MNIST dataset](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/linear_learner_mnist/linear_learner_mnist.html) | Usando el conjunto de datos MNIST, entrenamos un clasificador binario para predecir un solo dígito. |
| [How to Build a Multiclass Classifier?](https://sagemaker-examples.readthedocs.io/en/latest/scientific_details_of_algorithms/linear_learner_multiclass_classification/linear_learner_multiclass_classification.html) | Con el conjunto de datos Covertype del UCI, demostramos cómo entrenar un clasificador multiclase. |
| [How to Build a Machine Learning (ML) Pipeline for Inference? ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-python-sdk/scikit_learn_inference_pipeline/Inference%20Pipeline%20with%20Scikit-learn%20and%20Linear%20Learner.html) | Con un contenedor Scikit-learn, demostramos cómo crear una canalización de aprendizaje automático. end-to-end |
Para obtener instrucciones sobre cómo crear instancias de Jupyter Notebook y acceder a ellas, que puedes usar para ejecutar el ejemplo en IA, consulta. SageMaker [Instancias de Amazon SageMaker Notebook](nbi.md) Tras crear una instancia de bloc de notas y abrirla, selecciona 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 de aprendizaje lineal se encuentran en la sección de **introducción a algoritmos de Amazon**. Para abrir un cuaderno, elija su pestaña **Usar** y elija **Crear copia**.
# Cómo funciona el aprendizaje lineal
Existen tres pasos en la implementación del algoritmo de aprendizaje lineal: preprocesamiento, capacitación y validación.
## Paso 1: Preprocesar
La normalización, o el escalado de características, es un importante paso de preprocesamiento de algunas funciones de pérdida que garantizan que el modelo que se entrena en un conjunto de datos no esté dominado por el peso de una única característica. El algoritmo Linear Learner de Amazon SageMaker AI tiene una opción de normalización para facilitar este paso de preprocesamiento. Si se activa la normalización, el algoritmo primero se aplica a una pequeña muestra de datos para obtener el valor medio y la desviación estándar de cada característica y la etiqueta. Cada una de las características del conjunto de datos total se convierte para obtener la media de cero y se escala para que tenga la desviación estándar de la unidad.
**nota**
Para obtener unos mejores resultados, asegúrese de que los datos estén desordenados antes de la capacitación. Si la capacitación se realiza con datos ordenados, se podría producir un error.
Puede configurar si desea que el algoritmo de aprendizaje lineal normalice las etiquetas y los datos de la característica mediante los hiperparámetros `normalize_data` y `normalize_label`, respectivamente. De forma predeterminada, la normalización está habilitada en características y etiquetas para la regresión. Únicamente se pueden normalizar las características para la clasificación binaria; este es el comportamiento predeterminado.
## Paso 2: Capacitación
Con el algoritmo de aprendizaje lineal, usted capacita con una implementación distribuida de descenso de gradiente estocástico (SGD). Puede controlar el proceso de optimización eligiendo el algoritmo de optimización. Por ejemplo, puede optar por utilizar Adam AdaGrad, un gradiente de descenso estocástico u otros algoritmos de optimización. También debe especificar sus hiperparámetros, como, por ejemplo, impulso, tasa de aprendizaje y la tasa de aprendizaje programada. Si no está seguro de qué algoritmo o valor de hiperparámetro utilizar, debe elegir un valor predeterminado que funcione para la mayoría de conjuntos de datos.
Durante la capacitación, usted optimiza al mismo tiempo varios modelos, cada uno de ellos con objetivos ligeramente diferentes. Por ejemplo, puede variar la regularización L1 o L2 y probar diferentes ajustes de optimizador.
## Paso 3: Validación y ajuste del umbral
Cuando se entrenan varios modelos en paralelo, los modelos se evalúan con respecto a un conjunto de validación para seleccionar los modelos óptimos una vez que se complete la capacitación. Para la regresión, el modelo óptimo es el que consigue la mejor pérdida en el conjunto de validación. Para la clasificación, se utiliza una muestra del conjunto de validación para calibrar el umbral de clasificación. El modelo óptimo seleccionado es el que obtiene los mejores criterios de selección de clasificación binaria en el conjunto de validación. Algunos ejemplos de dichos criterios son la medida F1, la precisión y la pérdida de entropía cruzada.
**nota**
Si no se proporciona un conjunto de validación para el algoritmo, no es posible evaluar y seleccionar el modelo óptimo. Para aprovechar la selección del modelo y la capacitación paralela, asegúrese de proporcionar un conjunto de validación para el algoritmo.
# Hiperparámetros de aprendizaje lineal
La siguiente tabla contiene los hiperparámetros del algoritmo de aprendizaje lineal. Estos son los parámetros que establecen los usuarios para facilitar la estimación de los parámetros del modelo a partir de los datos. Los hiperparámetros necesarios que deben establecerse se enumerarán en primer lugar, en orden alfabético. Los hiperparámetros opcionales que se pueden establecer aparecen a continuación en la lista, también en orden alfabético. Cuando un hiperparámetro se establece en`auto`, Amazon SageMaker AI calculará y establecerá automáticamente el valor de ese hiperparámetro.
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| num\$1classes | El número de clases para la respuesta variable. El algoritmo presupone que las clases se etiquetan `0`, ..., `num_classes - 1`. **Obligatorio** cuando `predictor_type` es `multiclass_classifier`. De lo contrario, el algoritmo hace caso omiso de él. Valores válidos: Enteros comprendidos entre 3 y 1 000 000. |
| predictor\$1type | Especifica el tipo de variable de destino como una clasificación binaria, clasificación de varias clases, o regresión. **Obligatorio** Valores válidos: `binary_classifier`, `multiclass_classifier` o `regressor` |
| accuracy\$1top\$1k | A la hora de calcular la métrica de precisión de top-k para la clasificación de varias clases, el valor de *k*. Si el modelo asigna una de las puntuaciones top-k a la verdadera etiqueta, el ejemplo será puntuado como correcto. **Opcional** Valores válidos: enteros positivos Valor predeterminado: 3 |
| balance\$1multiclass\$1weights | Especifica si se debe usar ponderaciones de clase, que proporcionan a cada clase igual importancia en la función de pérdida. Solo se usa cuando el `predictor_type` es `multiclass_classifier`. **Opcional** Valores válidos: `true`, `false` Valor predeterminado: `false` |
| beta\$11 | Tasa de decremento exponencial para las estimaciones del primer momento. Se aplica solo cuando el valor de `optimizer` es `adam`. **Opcional** Valores válidos: `auto` o de valor de punto flotante comprendido entre 0 y 1,0 Valor predeterminado: `auto` |
| beta\$12 | Tasa de decremento exponencial para las estimaciones de segundo momento. Se aplica solo cuando el valor de `optimizer` es `adam`. **Opcional** Valores válidos: `auto` o entero de punto flotante comprendido entre 0 y 1,0 Valor predeterminado: `auto` |
| bias\$1lr\$1mult | Permite una tasa de aprendizaje diferente para el plazo de sesgo. La tasa de aprendizaje real para el sesgo es `learning_rate` \$1 `bias_lr_mult`. **Opcional** Valores válidos: `auto` o entero positivo de punto flotante Valor predeterminado: `auto` |
| bias\$1wd\$1mult | Permite una regularización diferente para el plazo de sesgo. La ponderación de regularización de L2 real para el sesgo es `wd` \$1 `bias_wd_mult`. De forma predeterminada, no hay ninguna regularización en el plazo de sesgo. **Opcional** Valores válidos: `auto` o entero no negativo de punto flotante Valor predeterminado: `auto` |
| binary\$1classifier\$1model\$1selection\$1criteria | Cuando `predictor_type` se establece en `binary_classifier`, los criterios de evaluación del modelo para el conjunto de datos de validación (o para el conjunto de datos de capacitación si no proporciona un conjunto de datos de validación). Los criterios incluyen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/ll_hyperparameters.html) **Opcional** Valores válidos: `accuracy`, `f_beta`, `precision_at_target_recall`, `recall_at_target_precision`, o `loss_function` Valor predeterminado: `accuracy` |
| early\$1stopping\$1patience | El número de fechas de inicio para esperar antes de finalizar la capacitación si no se realiza ninguna mejora en la métrica relevante. Si ha proporcionado un valor para binary\$1classifier\$1model\$1selection\$1criteria. la métrica es dicho valor. De lo contrario, la métrica es la misma que el valor especificado para el hiperparámetro loss. La métrica se evalúa en los datos de validación. Si no ha proporcionado datos de validación, la métrica siempre la misma que el valor especificado para el hiperparámetro `loss` y se evalúa en los datos de capacitación. Para deshabilitar la parada precoz, establezca `early_stopping_patience` en un valor mayor que el valor especificado para `epochs`.**Opcional**Valores válidos: número entero positivoValor predeterminado: 3 |
| early\$1stopping\$1tolerance | Tolerancia relativa para medir una mejora en la pérdida. Si la proporción de la mejora en la pérdida dividida por la mejor pérdida anterior es inferior a este valor, la detención precoz considera que la mejora es cero. **Opcional** Valores válidos: Entero positivo de punto flotante Valor predeterminado: 0.001 |
| epochs | Número máximo de iteraciones en los datos de capacitación. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 15 |
| f\$1beta | El valor de beta que se ha de emplear al calcular las métricas de puntuación F para la clasificación binaria o de varias clases. También se utiliza si el valor definido para `binary_classifier_model_selection_criteria` es `f_beta`. **Opcional** Valores válidos: enteros positivos de punto flotante Valor predeterminado: 1.0 |
| feature\$1dim | El número de características en los datos de entrada. **Opcional** Valores válidos: `auto` o entero positivo Valores predeterminados: `auto` |
| huber\$1delta | El parámetro de pérdida de Huber. Durante la evaluación métrica y de capacitación, compute la pérdida L2 de errores inferiores a delata y de pérdida L1 de errores superiores a delta. **Opcional** Valores válidos: Entero positivo de punto flotante Valor predeterminado: 1.0 |
| init\$1bias | Ponderación inicial para el plazo de sesgo. **Opcional** Valores válidos: Entero de punto flotante Valor predeterminado: 0 |
| init\$1method | Establece la función de distribución inicial que se utiliza para ponderaciones de modelo. Las funciones incluyen: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/ll_hyperparameters.html) **Opcional** Valores válidos: `uniform` o `normal` Valor predeterminado: `uniform` |
| init\$1scale | Escala una distribución uniforme para ponderaciones de modelo. Se aplica solo cuando se establece el hiperparámetro `init_method` en `uniform`. **Opcional** Valores válidos: Entero positivo de punto flotante Valor predeterminado: 0.07 |
| init\$1sigma | La desviación estándar inicial para la distribución normal. Se aplica solo cuando se establece el hiperparámetro `init_method` en `normal`. **Opcional** Valores válidos: Entero positivo de punto flotante Valor predeterminado: 0,01 |
| l1 | El parámetro de regularización de L1. Si no desea utilizar la regularización de L1, establezca el valor en 0. **Opcional** Valores válidos: `auto` o número flotante no negativo Valor predeterminado: `auto` |
| learning\$1rate | El tamaño del paso usado por el optimizador para actualizaciones de parámetros. **Opcional** Valores válidos: `auto` o entero positivo de punto flotante Valor predeterminado: `auto`, cuyo valor depende del optimizador elegido. |
| loss | Especifica la función de pérdida. Las funciones de pérdida disponibles y sus valores predeterminados dependen del valor de `predictor_type`: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/ll_hyperparameters.html) Valores válidos: `auto`, `logistic`, `squared_loss`, `absolute_loss`, `hinge_loss`, `eps_insensitive_squared_loss`, `eps_insensitive_absolute_loss`, `quantile_loss` o `huber_loss` **Opcional** Valor predeterminado: `auto` |
| loss\$1insensitivity | El parámetro para el tipo de pérdida epsilon-insensible. Durante la evaluación métrica y de capacitación, cualquier error inferior a este valor se considera cero. **Opcional** Valores válidos: Entero positivo de punto flotante Valor predeterminado: 0,01 |
| lr\$1scheduler\$1factor | Para cada hiperparámetro `lr_scheduler_step`, la tasa de aprendizaje disminuye en esta cantidad. Se aplica solo cuando se establece el hiperparámetro `use_lr_scheduler` en `true`. **Opcional** Valores válidos: `auto` o positivo de punto flotante comprendido entre 0 y 1 Valor predeterminado: `auto` |
| lr\$1scheduler\$1minimum\$1lr | La tasa de aprendizaje nunca disminuye a un valor inferior al valor establecido para `lr_scheduler_minimum_lr`. Se aplica solo cuando se establece el hiperparámetro `use_lr_scheduler` en `true`. **Opcional** Valores válidos: `auto` o entero positivo de punto flotante Valores predeterminados: `auto` |
| lr\$1scheduler\$1step | El número de pasos entre disminuciones de la tasa de aprendizaje. Se aplica solo cuando se establece el hiperparámetro `use_lr_scheduler` en `true`. **Opcional** Valores válidos: `auto` o entero positivo Valor predeterminado: `auto` |
| margin | El margen para la función `hinge_loss`. **Opcional** Valores válidos: Entero positivo de punto flotante Valor predeterminado: 1.0 |
| mini\$1batch\$1size | El número de observaciones por minilote para el iterador de datos. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 1000 |
| momentum | El impulso del optimizador `sgd`. **Opcional** Valores válidos: `auto` o un entero de punto flotante comprendido entre 0 y 1,0 Valor predeterminado: `auto` |
| normalize\$1data | Normaliza los datos de la característica antes de la capacitación. La normalización de los datos convierte los datos de cada característica para que tengan una media de cero y los escala para que tenga la desviación estándar de la unidad. **Opcional** Valores válidos: `auto`, `true` o `false` Valor predeterminado: `true` |
| normalize\$1label | Normaliza la etiqueta. La normalización de las etiquetas cambia la etiqueta para que tenga una media de cero y la escala para que tenga la desviación estándar de la unidad. El valor `auto` predeterminado normaliza la etiqueta para problemas de regresión, pero no para problemas de clasificación. Si establece el hiperparámetro `normalize_label` en `true` para problemas de clasificación, el algoritmo hace caso omiso de él. **Opcional** Valores válidos: `auto`, `true` o `false` Valor predeterminado: `auto` |
| num\$1calibration\$1samples | Número de observaciones del conjunto de datos de validación para usar en la calibración de modelo (cuando se encuentra el mejor umbral). **Opcional** Valores válidos: `auto` o entero positivo Valor predeterminado: `auto` |
| num\$1models | Número de modelos para capacitación en paralelo. Para el valor predeterminado, `auto`, el algoritmo decide el número de modelos en paralelo a capacitar. Se realiza la capacitación de un modelo según el parámetro de capacitación determinado (regularización, optimizador y pérdida) y el resto mediante parámetros cerrados. **Opcional** Valores válidos: `auto` o entero positivo Valores predeterminados: `auto` |
| num\$1point\$1for\$1scaler | El número de puntos de datos a usar para calcular la normalización o para establecer plazos sin sesgo. **Opcional** Valores válidos: número entero positivo Valor predeterminado: 10,000 |
| optimizer | El algoritmo de optimización que se va a utilizar. **Opcional** Valores válidos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/ll_hyperparameters.html) Valor predeterminado: `auto`. El ajuste predeterminado de `auto` es `adam`. |
| positive\$1example\$1weight\$1mult | La ponderación asignada a ejemplos positivos cuando se capacita un clasificador binario. La ponderación de los ejemplos negativos se fija en 1. Si desea que el algoritmo elija una ponderación de manera que los errores en los ejemplos de clasificación negativos *frente a* positivos tenga el mismo impacto en la pérdida de capacitación, especifique `balanced`. Si desea que el algoritmo elija la ponderación que optimice el rendimiento, especifique `auto`. **Opcional** Valores válidos: `balanced`, `auto` o un entero positivo de punto flotante Valor predeterminado: 1.0 |
| quantile | El cuantil para pérdida de cuantil. Para el cuantil q, el modelo intenta producir predicciones de modo que el valor de `true_label` sea mayor que la predicción con probabilidad q. **Opcional** Valores válidos: entero de punto flotante comprendido entre 0 y 1 Valor predeterminado: 0,5 |
| target\$1precision | La precisión de destino. Si `binary_classifier_model_selection_criteria` tiene el valor `recall_at_target_precision`, entonces se mantiene precisión en este valor al mismo tiempo que se optimiza rellamada. **Opcional** Valores válidos: Entero de punto flotante comprendido entre 0 y 1,0 Valor predeterminado: 0.8 |
| target\$1recall | La rellamada de destino. Si `binary_classifier_model_selection_criteria` tiene el valor `precision_at_target_recall`, entonces se mantiene rellamada en este valor al mismo tiempo que se optimiza precisión. **Opcional** Valores válidos: Entero de punto flotante comprendido entre 0 y 1,0 Valor predeterminado: 0.8 |
| unbias\$1data | Establece las características sin sesgo antes de la capacitación de modo que la media sea 0. De forma predeterminada, los datos no están sesgados si el hiperparámetro `use_bias` se establece en `true`. **Opcional** Valores válidos: `auto`, `true` o `false` Valor predeterminado: `auto` |
| unbias\$1label | Establece las etiquetas sin sesgo antes de la capacitación de modo que la media sea 0. Se aplica a la regresión solo si el `use_bias` hiperparámetro se establece en `true`. **Opcional** Valores válidos: `auto`, `true` o `false` Valor predeterminado: `auto` |
| use\$1bias | Especifica si el modelo debe incluir un término de sesgo, que es el término interceptar en la ecuación lineal. **Opcional** Valores válidos: `true` o `false` Valor predeterminado: `true` |
| use\$1lr\$1scheduler | Cuándo usar un programador para la tasa de aprendizaje. Si desea utilizar un programador, especifique `true`. **Opcional** Valores válidos: `true` o `false` Valor predeterminado: `true` |
| wd | El parámetro de degradación de ponderación, que también se conoce como parámetro de regularización de L2. Si no desea utilizar la regularización de L2, establezca el valor en 0. **Opcional** Valores válidos: `auto` o entero no negativo de punto flotante Valor predeterminado: `auto` |
# Ajustar un modelo de aprendizaje lineal
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.
El algoritmo de aprendizaje lineal también dispone de un mecanismo interno para ajustar hiperparámetros independiente del ajuste de modelo automático que se describe aquí. De forma predeterminada, el algoritmo de aprendizaje lineal ajusta hiperparámetros capacitando varios modelos en paralelo. Cuando se utiliza ajuste de modelos automático, el mecanismo de ajuste de aprendizaje lineal interno está desactivado de forma automática. Esto establece el número de modelos paralelos, `num_models`, a 1. El algoritmo no tiene en cuenta los valores que establezca para `num_models`.
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 computadas por el algoritmo de aprendizaje lineal
El algoritmo de aprendizaje lineal informa de la las métricas en la siguiente tabla, que se calcula durante la capacitación. Elija uno de ellos como métrica objetivo. Para evitar sobreajustes, se recomienda ajustar el modelo en una métrica de validación en lugar de una capacitación métrica.
| Nombre de métrica | Description (Descripción) | Dirección de optimización |
| --- | --- | --- |
| test:absolute\$1loss | La pérdida absoluta del modelo final en el conjunto de datos de prueba. Esta métrica objetivo solo es válida para regresión. | Minimizar |
| test:binary\$1classification\$1accuracy | La precisión del modelo final en el conjunto de datos de prueba. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
| test:binary\$1f\$1beta | La puntuación F-beta del modelo final en el conjunto de datos de prueba. De forma predeterminada, se trata de la puntuación F1, que es la media armónica de la precisión y la recuperación. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
| test:dcg | La ganancia acumulada descontada del modelo final en el conjunto de datos de prueba. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| test:macro\$1f\$1beta | La puntuación F-beta del modelo final en el conjunto de datos de prueba. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| test:macro\$1precision | La precisión del modelo final en el conjunto de datos de prueba. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| test:macro\$1recall | La puntuación de exhaustividad del modelo final en el conjunto de datos de prueba. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| test:mse | El error cuadrático medio del modelo final en el conjunto de datos de prueba. Esta métrica objetivo solo es válida para regresión. | Minimizar |
| test:multiclass\$1accuracy | La precisión del modelo final en el conjunto de datos de prueba. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| test:multiclass\$1top\$1k\$1accuracy | La precisión entre las k etiquetas principales pronosticadas en el conjunto de datos de prueba. Si elige esta métrica como objetivo, le recomendamos establecer el valor de k mediante el hiperparámetro `accuracy_top_k`. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| test:objective\$1loss | El valor medio del función de pérdida objetivo en el conjunto de datos de prueba después de que el modelo sea capacitado. De forma predeterminada, la pérdida es la pérdida logística para clasificación binaria y pérdida cuadrática para regresión. Para establecer la pérdida a otros tipos, utilice el `loss` hiperparámetro. | Minimizar |
| test:precision | La precisión del modelo final en el conjunto de datos de prueba. Si elige esta métrica como objetivo, recomendamos configurar una rellamada objetivo estableciendo el `binary_classifier_model_selection` hiperparámetro en `precision_at_target_recall` y definir el valor para el `target_recall` hiperparámetro. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
| test:recall | La rellamada del modelo final en el conjunto de datos de prueba. Si elige esta métrica como objetivo, recomendamos configurar una precisión objetivo estableciendo el hiperparámetro `binary_classifier_model_selection` en `recall_at_target_precision` y definiendo el valor para el hiperparámetro `target_precision`. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
| test:roc\$1auc\$1score | El área bajo la curva característica operativa receptora (curva ROC) del modelo final en el conjunto de datos de prueba. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
| validation:absolute\$1loss | La pérdida absoluta del modelo final en el conjunto de datos de validación. Esta métrica objetivo solo es válida para regresión. | Minimizar |
| validation:binary\$1classification\$1accuracy | La precisión del modelo final en la validación del conjunto de datos de prueba. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
| validation:binary\$1f\$1beta | La puntuación F-beta del modelo final en la validación del conjunto de datos. De forma predeterminada, la puntuación F-beta es la puntuación F1, que es la media armónica de las métricas `validation:recall` y `validation:precision`. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
| validation:dcg | La ganancia acumulada descontada del modelo final en el conjunto de datos de validación. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| validation:macro\$1f\$1beta | La puntuación F-beta del modelo final en la validación del conjunto de datos. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| validation:macro\$1precision | La puntuación de precisión del modelo final en el conjunto de datos de validación. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| validation:macro\$1recall | La puntuación de exhaustividad del modelo final en el conjunto de datos de validación. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| validation:mse | El error cuadrático medio del modelo final en el conjunto de datos de validación. Esta métrica objetivo solo es válida para regresión. | Minimizar |
| validation:multiclass\$1accuracy | La precisión del modelo final en la validación del conjunto de datos de prueba. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| validation:multiclass\$1top\$1k\$1accuracy | La precisión entre las k etiquetas principales pronosticadas en el conjunto de datos de validación. Si elige esta métrica como objetivo, le recomendamos establecer el valor de k mediante el hiperparámetro `accuracy_top_k`. Esta métrica objetivo solo es válida para la clasificación multiclase. | Maximizar |
| validation:objective\$1loss | El valor medio de la función de pérdida objetivo en el conjunto de datos de validación de cada fecha de inicio. De forma predeterminada, la pérdida es la pérdida logística para clasificación binaria y pérdida cuadrática para regresión. Para establecer la pérdida a otros tipos, utilice el `loss` hiperparámetro. | Minimizar |
| validation:precision | La precisión del modelo final en el conjunto de datos de validación. Si elige esta métrica como objetivo, recomendamos configurar una rellamada objetivo estableciendo el `binary_classifier_model_selection` hiperparámetro en `precision_at_target_recall` y definir el valor para el `target_recall` hiperparámetro. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
| validation:recall | La precisión del modelo final en el conjunto de datos de validación. Si elige esta métrica como objetivo, recomendamos configurar una precisión objetivo estableciendo el hiperparámetro `binary_classifier_model_selection` en `recall_at_target_precision` y definiendo el valor para el hiperparámetro `target_precision`. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
| validation:rmse | La raíz del error cuadrático medio del modelo final en el conjunto de datos de validación. Esta métrica objetivo solo es válida para regresión. | Minimizar |
| validation:roc\$1auc\$1score | El área bajo la curva característica operativa receptora (curva ROC) del modelo final en el conjunto de datos de validación. Esta métrica objetivo solo es válida para la clasificación binaria. | Maximizar |
## Ajuste de hiperparámetros de aprendizaje lineal
Puede ajustar un modelo de aprendizaje lineal con los siguientes hiperparámetros.
| Nombre del parámetro | Tipo de parámetro | Intervalos recomendados |
| --- | --- | --- |
| wd | `ContinuousParameterRanges` | `MinValue: ``1e-7`, `MaxValue`: `1` |
| l1 | `ContinuousParameterRanges` | `MinValue`: `1e-7`, `MaxValue`: `1` |
| learning\$1rate | `ContinuousParameterRanges` | `MinValue`: `1e-5`, `MaxValue`: `1` |
| mini\$1batch\$1size | `IntegerParameterRanges` | `MinValue`: `100`, `MaxValue`: `5000` |
| use\$1bias | `CategoricalParameterRanges` | `[True, False]` |
| positive\$1example\$1weight\$1mult | `ContinuousParameterRanges` | `MinValue`: 1e-5, `MaxValue`: `1e5` |
# Formatos de respuesta de aprendizaje lineal
## Formato de respuesta JSON
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). Los siguientes son los formatos de salida disponibles para el algoritmo de aprendizaje lineal de SageMaker IA.
**Clasificación binaria**
```
let response = {
"predictions": [
{
"score": 0.4,
"predicted_label": 0
}
]
}
```
**Clasificación multiclase**
```
let response = {
"predictions": [
{
"score": [0.1, 0.2, 0.4, 0.3],
"predicted_label": 2
}
]
}
```
**Regresión**
```
let response = {
"predictions": [
{
"score": 0.4
}
]
}
```
## Formatos de respuesta JSONLINES
**Clasificación binaria**
```
{"score": 0.4, "predicted_label": 0}
```
**Clasificación multiclase**
```
{"score": [0.1, 0.2, 0.4, 0.3], "predicted_label": 2}
```
**Regresión**
```
{"score": 0.4}
```
## Formatos de respuesta RECORDIO
**Clasificación binaria**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
},
'predicted_label': {
keys: [],
values: [0.0] # float32
}
}
}
]
```
**Clasificación multiclase**
```
[
Record = {
"features": [],
"label": {
"score": {
"values": [0.1, 0.2, 0.3, 0.4]
},
"predicted_label": {
"values": [3]
}
},
"uid": "abc123",
"metadata": "{created_at: '2017-06-03'}"
}
]
```
**Regresión**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
}
}
}
]
```
# TabTransformer
[TabTransformer](https://arxiv.org/abs/2012.06678)es una novedosa arquitectura de modelado profundo de datos tabulares para el aprendizaje supervisado. La TabTransformer arquitectura se basa en self-attention-based Transformers. Las capas de transformadores convierten las incrustaciones de rasgos categóricos en incrustaciones contextuales sólidas para lograr una mayor precisión en la predicción. Además, las incrustaciones contextuales de las que se ha aprendido TabTransformer son muy resistentes a las funciones de datos ausentes o ruidosas, y ofrecen una mejor interpretabilidad. Esta página incluye información sobre las recomendaciones de instancias de Amazon EC2 y cuadernos de muestra para. TabTransformer
# ¿Cómo usar la IA? SageMaker TabTransformer
Se puede utilizar TabTransformer como un algoritmo integrado de Amazon SageMaker AI. En la siguiente sección se describe cómo usarlo TabTransformer con el SDK de SageMaker Python. Para obtener información sobre cómo usarlo TabTransformer desde la interfaz de usuario clásica de Amazon SageMaker Studio, consulte[SageMaker JumpStart modelos preentrenados](studio-jumpstart.md).
+ ** TabTransformer Utilícelo como algoritmo integrado**
Utilice el algoritmo TabTransformer integrado para crear un contenedor de TabTransformer entrenamiento, como se muestra en el siguiente ejemplo de código. Puede detectar automáticamente el URI de la imagen del algoritmo TabTransformer integrado mediante la `image_uris.retrieve` API de SageMaker IA (o la `get_image_uri` API si utiliza [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) versión 2).
Tras especificar el URI de la TabTransformer imagen, puede utilizar el TabTransformer contenedor para crear un estimador mediante la API SageMaker AI Estimator e iniciar un trabajo de formación. El algoritmo TabTransformer integrado se ejecuta en modo script, pero el script de entrenamiento se proporciona automáticamente y no es necesario reemplazarlo. Si tiene una amplia experiencia en el uso del modo guion para crear un trabajo de SageMaker formación, puede incorporar sus propios guiones de TabTransformer formación.
```
from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "pytorch-tabtransformerclassification-model", "*", "training"
training_instance_type = "ml.p3.2xlarge"
# Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None,
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type
)
# Retrieve the training script
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
)
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)
# Sample training data is available in this bucket
training_data_bucket = f"jumpstart-cache-prod-{aws_region}"
training_data_prefix = "training-datasets/tabular_binary/"
training_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/train"
validation_dataset_s3_path = f"s3://{training_data_bucket}/{training_data_prefix}/validation"
output_bucket = sess.default_bucket()
output_prefix = "jumpstart-example-tabular-training"
s3_output_location = f"s3://{output_bucket}/{output_prefix}/output"
from sagemaker import hyperparameters
# Retrieve the default hyperparameters for training the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters[
"n_epochs"
] = "50"
print(hyperparameters)
from sagemaker.estimator import Estimator
from sagemaker.utils import name_from_base
training_job_name = name_from_base(f"built-in-algo-{train_model_id}-training")
# Create SageMaker Estimator instance
tabular_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 SageMaker Training job by passing the S3 path of the training data
tabular_estimator.fit(
{
"training": training_dataset_s3_path,
"validation": validation_dataset_s3_path,
}, logs=True, job_name=training_job_name
)
```
Para obtener más información sobre cómo configurarlo TabTransformer como algoritmo integrado, consulte los siguientes ejemplos de cuadernos.
+ [Clasificación tabular con el algoritmo Amazon SageMaker AI TabTransformer](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Classification_TabTransformer.ipynb)
+ [Regresión tabular con el algoritmo Amazon SageMaker AI TabTransformer](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Regression_TabTransformer.ipynb)
# Interfaz de entrada y salida para el algoritmo TabTransformer
TabTransformer funciona con datos tabulares, donde las filas representan las observaciones, una columna representa la variable o etiqueta objetivo y las columnas restantes representan las características.
La implementación de SageMaker IA TabTransformer es compatible con CSV para el entrenamiento y la inferencia:
+ Para la **formación ContentType**, las entradas válidas deben ser *texto/csv*.
+ *Para la **inferencia ContentType**, las entradas válidas deben ser text/csv.*
**nota**
Para la capacitación de CSV, el algoritmo asume la variable de destino en la primera columna y ese CSV no dispone de un registro de encabezado.
Para la inferencia de CSV, el algoritmo asume que la entrada de CSV no dispone de la columna de etiqueta.
**Formato de entrada para los datos de entrenamiento, los datos de validación y las características categóricas**
Ten cuidado con el formato de los datos de entrenamiento para introducirlos en el modelo. TabTransformer Debe proporcionar la ruta a un bucket de Amazon S3 que contenga los datos de entrenamiento y de validación. También puede incluir una lista de características categóricas. Utilice los canales `training` y `validation` para proporcionar los datos de entrada. o utilice solo el canal `training` si lo prefiere.
**Uso de ambos canales (`training` y `validation`)**
Puede proporcionar los datos de entrada mediante dos rutas S3, una para el canal `training` y otra para el canal `validation`. Cada ruta S3 puede ser un prefijo S3 que apunte a uno o más archivos CSV, o una ruta S3 completa que apunte a un archivo CSV específico. Las variables de destino deben estar en la primera columna del archivo CSV. Las variables predictoras (características) deben estar en las columnas restantes. Si se proporcionan varios archivos CSV para los `validation` canales `training` o, el TabTransformer algoritmo concatena los archivos. Los datos de validación se utilizan para calcular una puntuación de validación al final de cada iteración de potenciación. Hay una interrupción anticipada cuando la puntuación de validación deja de mejorar.
Si los predictores incluyen características categóricas, puede proporcionar un archivo JSON con el nombre `categorical_index.json` en la misma ubicación que los archivos de datos de entrenamiento. Si proporciona un archivo JSON para las características categóricas, el canal `training` debe apuntar a un prefijo S3, y no a un archivo CSV específico. Este archivo debe contener un diccionario de Python donde la clave sea la cadena `"cat_index_list"` y el valor sea una lista de enteros únicos. Cada número entero de la lista de valores debe indicar el índice de columnas de las características categóricas correspondientes en el archivo CSV de datos de entrenamiento. Cada valor debe ser un entero positivo (mayor de cero, ya que cero representa el valor objetivo), menor que el `Int32.MaxValue` (2147483647) y menor que el número total de columnas. Solo debe haber un archivo JSON de índice categórico.
**Uso del canal `training` exclusivamente**
También puede proporcionar sus datos de entrada mediante una única ruta S3 para el canal `training`. Esta ruta S3 debe apuntar a un directorio con un subdirectorio denominado `training/` que contenga uno o más archivos CSV. Si lo desea, puede incluir otro subdirectorio en la misma ubicación, denominado `validation/`, que también tenga uno o más archivos CSV. Si no se proporcionan los datos de validación, se toma una muestra aleatoria del 20 % de los datos de entrenamiento para que ejerzan como datos de validación. Si los predictores contienen características categóricas, puede proporcionar un archivo JSON con el nombre `categorical_index.json` en la misma ubicación que los subdirectorios de datos.
**nota**
En el modo de entrada de entrenamiento de CSV, la memoria total disponible para el algoritmo (el recuento de instancias multiplicado por la memoria disponible en `InstanceType`) debe poder contener el conjunto de datos de entrenamiento.
## Recomendación de instancia de Amazon EC2 para el algoritmo TabTransformer
SageMaker La IA TabTransformer admite el entrenamiento de CPU y GPU de instancia única. A pesar de que los costes por instancia son más altos, GPUs entrene más rápido, lo que las hace más rentables. Para aprovechar la capacitación en GPU, especifique el tipo de instancia como una de las instancias de GPU (por ejemplo, P3). SageMaker TabTransformer Actualmente, la IA no admite el entrenamiento con varias GPU.
## TabTransformer ejemplos de cuadernos
La siguiente tabla describe una variedad de cuadernos de muestra que abordan diferentes casos de uso del TabTransformer algoritmo Amazon SageMaker AI.
****
| **Título del cuaderno** | **Descripción** |
| --- | --- |
| [Clasificación tabular con el algoritmo Amazon SageMaker AI TabTransformer ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Classification_TabTransformer.ipynb) | Este cuaderno muestra el uso del TabTransformer algoritmo Amazon SageMaker AI para entrenar y alojar un modelo de clasificación tabular. |
| [Regresión tabular con el algoritmo Amazon SageMaker AI TabTransformer ](https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/tabtransformer_tabular/Amazon_Tabular_Regression_TabTransformer.ipynb) | Este cuaderno muestra el uso del TabTransformer algoritmo Amazon SageMaker AI para entrenar y alojar un modelo de regresión tabular. |
Para obtener instrucciones sobre cómo crear instancias de Jupyter Notebook y acceder a ellas, que puede utilizar para ejecutar el ejemplo en SageMaker IA, consulte. [Instancias de Amazon SageMaker Notebook](nbi.md) Tras crear una instancia de bloc de notas y abrirla, selecciona 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 TabTransformer funciona
TabTransformer es una novedosa arquitectura de modelado profundo de datos tabulares para el aprendizaje supervisado. TabTransformer Se basa en Transformers basados en la autoatención. Las capas de transformadores convierten las incrustaciones de rasgos categóricos en incrustaciones contextuales sólidas para lograr una mayor precisión en la predicción. Además, las incrustaciones contextuales de las que se ha aprendido TabTransformer son muy resistentes a las funciones de datos ausentes o ruidosas, y proporcionan una mejor interpretabilidad.
TabTransformer tiene un buen rendimiento en las competiciones de aprendizaje automático debido a su sólido manejo de una variedad de tipos de datos, relaciones y distribuciones y a la diversidad de hiperparámetros que se pueden ajustar con precisión. Se puede utilizar TabTransformer para problemas de regresión, clasificación (binaria y multiclase) y clasificación.
El siguiente diagrama ilustra la TabTransformer arquitectura.
![\[La arquitectura de TabTransformer.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/tabtransformer_illustration.png)
Para obtener más información, consulte *[TabTransformer: Modelado de datos tabulares mediante incrustaciones contextuales](https://arxiv.org/abs/2012.06678)*.
# TabTransformer hiperparámetros
La siguiente tabla contiene el subconjunto de hiperparámetros que se requieren o se utilizan con más frecuencia para el algoritmo Amazon SageMaker AI TabTransformer . Los usuarios establecen estos parámetros para facilitar la estimación de los parámetros del modelo a partir de los datos. El TabTransformer algoritmo de SageMaker IA es una implementación del paquete de código abierto [TabTransformer](https://github.com/jrzaurin/pytorch-widedeep).
**nota**
Los hiperparámetros predeterminados se basan en conjuntos de datos de ejemplo de [TabTransformer ejemplos de cuadernos](tabtransformer.md#tabtransformer-sample-notebooks).
El TabTransformer algoritmo de SageMaker IA elige automáticamente una métrica de evaluación y una función objetivo en función del tipo de problema de clasificación. El TabTransformer algoritmo detecta el tipo de problema de clasificación en función del número de etiquetas de los datos. Para los problemas de regresión, la métrica de evaluación es R² y la función objetivo es el error cuadrático medio. Para los problemas de clasificación binaria, la métrica de evaluación y la función objetivo son la entropía cruzada binaria. Para los problemas de clasificación multiclase, la métrica de evaluación y la función objetivo son la entropía cruzada multiclase.
**nota**
Las funciones TabTransformer de métrica y objetivo de evaluación no están disponibles actualmente como hiperparámetros. En cambio, el algoritmo TabTransformer integrado de SageMaker IA detecta automáticamente el tipo de tarea de clasificación (regresión, binaria o multiclase) en función del número de enteros únicos de la columna de etiquetas y asigna una métrica de evaluación y una función objetivo.
| Nombre del parámetro | Description (Descripción) |
| --- | --- |
| n\$1epochs | Número de epochs (fechas de inicio) para entrenar la red neuronal profunda. Valores válidos: entero positivo. Valor predeterminado: `5`. |
| patience | El entrenamiento se detendrá si una métrica de un punto de datos de validación no mejora en la última ronda `patience`. Valores válidos: entero, rango (`2`, `60`). Valor predeterminado: `10`. |
| learning\$1rate | La velocidad a la que se actualizan los pesos del modelo después de pasar por cada lote de ejemplos de entrenamiento. Valores válidos: flotante, rango (número de coma flotante positivo). Valor predeterminado: `0.001`. |
| batch\$1size | El número de ejemplos propagados a través de la red. Valores válidos: entero, rango (`1`, `2048`). Valor predeterminado: `256`. |
| input\$1dim | La dimensión de las incrustaciones para codificar las columnas categóricas o continuas. Valores válidos: cadena, cualquiera de los siguientes (`"16"`, `"32"`, `"64"`, `"128"`, `"256"` o `"512"`). Valor predeterminado: `"32"`. |
| n\$1blocks | El número de bloques codificadores Transformer. Valores válidos: entero, rango (`1`, `12`). Valor predeterminado: `4`. |
| attn\$1dropout | Tasa de eliminación aplicada a las capas de atención Multi-Head. Valores válidos: flotante, rango (`0`, `1`). Valor predeterminado: `0.2`. |
| mlp\$1dropout | La tasa de abandono se aplica a la FeedForward red dentro de las capas del codificador y a las capas MLP finales situadas por encima de los codificadores Transformer. Valores válidos: flotante, rango (`0`, `1`). Valor predeterminado: `0.1`. |
| frac\$1shared\$1embed | La fracción de incrustaciones que comparten todas las diferentes categorías de una columna en particular. Valores válidos: flotante, rango (`0`, `1`). Valor predeterminado: `0.25`. |
# Ajuste un modelo TabTransformer
El *ajuste de modelo automático*, también conocido como ajuste de hiperparámetros, encuentra la mejor versión de un modelo ejecutando distintas tareas que prueban una serie de hiperparámetros en los conjuntos de datos de validación y entrenamiento. El ajuste del modelo se centra en los siguientes hiperparámetros:
**nota**
La función objetivo de aprendizaje y la métrica de evaluación se asignan automáticamente en función del tipo de tarea de clasificación, que viene determinada por el número de enteros únicos en la columna de etiqueta. Para obtener más información, consulte [TabTransformer hiperparámetros](tabtransformer-hyperparameters.md).
+ Una función objetivo de aprendizaje que se debe optimizar durante el entrenamiento con modelos.
+ Una métrica de evaluación que se utiliza para evaluar el rendimiento del modelo durante la validación.
+ Un conjunto de hiperparámetros y un rango de valores para emplear al ajustar el modelo automáticamente.
El ajuste de modelo automático busca los hiperparámetros elegidos con el objetivo de encontrar una combinación de valores que genere un modelo capaz de optimizar la métrica de evaluación seleccionada.
**nota**
El ajuste automático de modelos solo TabTransformer está disponible en Amazon SageMaker SDKs, no en la consola de SageMaker IA.
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 de evaluación calculadas por el TabTransformer algoritmo
El TabTransformer algoritmo de SageMaker IA calcula las siguientes métricas para utilizarlas en la validación del modelo. La métrica de evaluación se asigna automáticamente en función del tipo de tarea de clasificación, que viene determinada por el número de enteros únicos en la columna de etiqueta.
| Nombre de métrica | Description (Descripción) | Dirección de optimización | Patrón de expresiones regulares |
| --- | --- | --- | --- |
| r2 | R² | maximizar | "metrics=\$1'r2': (\$1\$1S\$1)\$1" |
| f1\$1score | entropía cruzada binaria | maximizar | "metrics=\$1'f1': (\$1\$1S\$1)\$1" |
| accuracy\$1score | entropía cruzada multiclase | maximizar | "metrics=\$1'accuracy': (\$1\$1S\$1)\$1" |
## Hiperparámetros ajustables TabTransformer
Ajuste el TabTransformer modelo con los siguientes hiperparámetros. Los hiperparámetros que tienen el mayor efecto en la optimización de las métricas de TabTransformer evaluación son:`learning_rate`,`input_dim`, `n_blocks` `attn_dropout``mlp_dropout`, y. `frac_shared_embed` Para obtener una lista de todos los TabTransformer hiperparámetros, consulte. [TabTransformer hiperparámetros](tabtransformer-hyperparameters.md)
| Nombre del parámetro | Tipo de parámetro | Intervalos recomendados |
| --- | --- | --- |
| learning\$1rate | ContinuousParameterRanges | MinValue: 0,001, MaxValue: 0,01 |
| input\$1dim | CategoricalParameterRanges | [16, 32, 64, 128, 256, 512] |
| n\$1blocks | IntegerParameterRanges | MinValue: 1, MaxValue 12 |
| attn\$1dropout | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,8 |
| mlp\$1dropout | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,8 |
| frac\$1shared\$1embed | ContinuousParameterRanges | MinValue: 0,0, MaxValue 0,5 |
# XGBoost algoritmo con Amazon SageMaker AI
El [XGBoost](https://github.com/dmlc/xgboost)(eXtreme Gradient Boosting) es una implementación popular y eficiente de código abierto del algoritmo de árboles potenciados por gradiente. La potenciación de gradientes es un algoritmo de aprendizaje supervisado que intenta predecir con precisión una variable de destino mediante la combinación de varias estimaciones a partir de un conjunto de modelos más simples. El XGBoost algoritmo funciona bien en las competiciones de aprendizaje automático por las siguientes razones:
+ Su potente gestión de distintos tipos de datos, relaciones y distribuciones.
+ La variedad de hiperparámetros que se pueden refinar.
Se puede utilizar XGBoost para problemas de regresión, clasificación (binaria y multiclase) y clasificación.
Puede utilizar la nueva versión del XGBoost algoritmo como:
+ Un algoritmo integrado de Amazon SageMaker AI.
+ Un marco para ejecutar scripts de entrenamiento en sus entornos locales.
Esta implementación ocupa menos espacio de memoria, tiene un mejor registro, una validación de hiperparámetros mejorada y un conjunto mayor de métricas en comparación con las versiones originales. Proporciona un guion de formación XGBoost `estimator` que ejecuta en un XGBoost entorno gestionado. La versión actual de SageMaker AI XGBoost se basa en las XGBoost versiones originales 1.0, 1.2, 1.3, 1.5, 1.7 y 3.0.
Para obtener más información sobre el XGBoost algoritmo Amazon SageMaker AI, consulta las siguientes entradas del blog:
+ [Presentamos el contenedor de XGBoost algoritmos Amazon SageMaker AI de código abierto](https://aws.amazon.com/blogs/machine-learning/introducing-the-open-source-amazon-sagemaker-xgboost-algorithm-container/)
+ [Amazon SageMaker AI XGBoost ahora ofrece entrenamiento de GPU totalmente distribuido](https://aws.amazon.com/blogs/machine-learning/amazon-sagemaker-xgboost-now-offers-fully-distributed-gpu-training/)
## Versiones compatibles
Para obtener más información, consulta nuestra [política de soporte](https://docs.aws.amazon.com/sagemaker/latest/dg/pre-built-containers-support-policy.html#pre-built-containers-support-policy-ml-framework).
+ Modo Framework (código abierto): 1.2-1, 1.2-2, 1.3-1, 1.5-1, 1.7-1, 3.0-5
+ Modo de algoritmo: 1.2-1, 1.2-2, 1.3-1, 1.5-1, 1.7-1, 3.0-5
**aviso**
Debido a la capacidad de procesamiento requerida, la versión 3.0-5 de SageMaker AI no XGBoost es compatible con las instancias de GPU de la familia de instancias P3 para fines de entrenamiento o inferencia.
**aviso**
Debido a que los paquetes son compatibles, la versión 3.0-5 de SageMaker AI XGBoost no admite el depurador. SageMaker
**aviso**
Debido a la capacidad de procesamiento requerida, la versión 1.7-1 de SageMaker AI no XGBoost es compatible con las instancias de GPU de la familia de instancias P2 para fines de entrenamiento o inferencia.
**aviso**
Modo de aislamiento de red: no actualice pip a una versión posterior a la 25.2. Las versiones más recientes pueden intentar recuperar las herramientas de configuración de PyPI durante la instalación del módulo.
**importante**
Cuando recuperes el URI de la XGBoost imagen SageMaker AI, no utilices `:latest` ni `:1` para la etiqueta URI de la imagen. Debe especificar uno de ellos [Versiones compatibles](#xgboost-supported-versions) para elegir el XGBoost contenedor SageMaker administrado por IA con la versión de XGBoost paquete nativa que desee usar. Para encontrar la versión del paquete migrada a los XGBoost contenedores de SageMaker IA, consulte las [rutas de registro y el código de ejemplo de Docker](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html). A continuación Región de AWS, elige la tuya y navega hasta la sección **XGBoost (algoritmo)**.
**aviso**
Las versiones XGBoost 0.90 están en desuso. Se ha dejado de ofrecer soporte para las actualizaciones de seguridad o las correcciones de errores de la XGBoost versión 0.90. Le recomendamos encarecidamente que actualice la XGBoost versión a una de las versiones más recientes.
**nota**
XGBoost La versión 1.1 no es compatible con la SageMaker IA. XGBoost La 1.1 tiene una capacidad insuficiente para ejecutar predicciones cuando la entrada de prueba tiene menos funciones que los datos de entrenamiento de las entradas LIBSVM. Esta capacidad se restableció en XGBoost la versión 1.2. Considere la posibilidad de utilizar SageMaker AI XGBoost 1.2-2 o una versión posterior.
**nota**
Puedes usar la XGBoost versión 1.0-1, pero no cuenta con soporte oficial.
## Recomendación de instancia EC2 para el algoritmo XGBoost
SageMaker La IA XGBoost admite el entrenamiento y la inferencia de la CPU y la GPU. Las recomendaciones de instancias dependen de las necesidades de formación e inferencia, así como de la versión del XGBoost algoritmo. Seleccione una de las siguientes opciones para obtener más información:
+ [Entrenamiento con CPU](#Instance-XGBoost-training-cpu)
+ [Entrenamiento con GPU](#Instance-XGBoost-training-gpu)
+ [Entrenamiento distribuido con CPU](#Instance-XGBoost-distributed-training-cpu)
+ [Entrenamiento distribuido con GPU](#Instance-XGBoost-distributed-training-gpu)
+ [Inferencia](#Instance-XGBoost-inference)
### Formación
El XGBoost algoritmo de SageMaker IA admite el entrenamiento de la CPU y la GPU.
#### Entrenamiento con CPU
SageMaker La IA XGBoost 1.0-1 o una versión anterior solo se entrena con CPUs ella. Se trata de un algoritmo de vinculación de memoria (como se opone en la vinculación de computación). Por lo tanto, una instancia de computación de uso general (por ejemplo, M5) es una opción mejor que una instancia optimizada de computación (por ejemplo, C4). Además, recomendamos que disponga de suficiente memoria en total en las instancias seleccionadas para almacenar los datos de capacitación. Admite el uso del espacio en disco para gestionar datos que no caben en la memoria principal. Esto se debe a la out-of-core función disponible con el modo de entrada libsvm. Aun así, escribir archivos de caché en el disco ralentiza el tiempo de procesamiento del algoritmo.
#### Entrenamiento con GPU
SageMaker La XGBoost versión 1.2-2 o posterior de AI admite el entrenamiento con la GPU. A pesar de que los costes por instancia son más altos, GPUs entrene más rápido, lo que las hace más rentables.
SageMaker XGBoost La versión 1.2-2 o posterior de AI admite las familias de instancias de GPU P2, P3, G4dn y G5.
SageMaker La XGBoost versión 1.7-1 o posterior de AI admite las familias de instancias de GPU P3, G4dn y G5. Tenga en cuenta que, debido a los requisitos de capacidad informática, la versión 1.7-1 o posterior no es compatible con la familia de instancias P2.
SageMaker La XGBoost versión 3.0-5 o posterior de AI es compatible con las familias de instancias de GPU G4dn y G5. Ten en cuenta que, debido a los requisitos de capacidad de procesamiento, la versión 3.0-5 o posterior no es compatible con la familia de instancias P3.
Para sacar partido del entrenamiento con la GPU:
+ Especifica el tipo de instancia como una de las instancias de GPU (por ejemplo, G4dn)
+ Defina el `tree_method` hiperparámetro `gpu_hist` en su script existente XGBoost
### Entrenamiento distribuido
SageMaker La IA XGBoost admite instancias de CPU y GPU para el entrenamiento distribuido.
#### Entrenamiento distribuido con CPU
Para ejecutar el entrenamiento con CPU en varias instancias, defina el parámetro `instance_count` del estimador en un valor superior a uno. Los datos de entrada se deben dividir entre el número total de instancias.
##### División de datos de entrada entre las instancias
Divida los datos de entrada mediante los siguientes pasos:
1. Separe los datos de entrada en archivos más pequeños. La cantidad de archivos debe ser, al menos, igual a la cantidad de instancias utilizadas para el entrenamiento distribuido. El uso de varios archivos más pequeños, en lugar de uno grande, también reduce el tiempo de descarga de datos para el trabajo de entrenamiento.
1. Al crear la tuya [TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html), establece el parámetro de distribución en`ShardedByS3Key`. Con esto, cada instancia recibe aproximadamente *1/n* del número de archivos de S3 si hay *n* instancias especificadas en el trabajo de entrenamiento.
#### Entrenamiento distribuido con GPU
Puede utilizar el entrenamiento distribuido con instancias de una o varias GPU.
**Entrenamiento distribuido con instancias de una sola GPU**
SageMaker XGBoost Las versiones 1.2-2 a 1.3-1 de AI solo admiten el entrenamiento de instancias con una sola GPU. Esto significa que, aunque seleccione una instancia con varias GPU, solo se utilizará una GPU por instancia.
Debe dividir los datos de entrada entre el número total de instancias si:
+ Utilizas las XGBoost versiones 1.2-2 a 1.3-1.
+ No necesita utilizar instancias con varias GPU.
Para obtener más información, consulte [División de datos de entrada entre las instancias](#Instance-XGBoost-distributed-training-divide-data).
**nota**
Las versiones 1.2-2 a 1.3-1 de SageMaker AI XGBoost solo utilizan una GPU por instancia, incluso si eliges una instancia con varias GPU.
**Entrenamiento distribuido con instancias de varias GPU**
[A partir de la versión 1.5-1, la SageMaker IA XGBoost ofrece formación distribuida sobre la GPU con Dask.](https://www.dask.org/) Con Dask, puede utilizarlos todos GPUs cuando utilice una o más instancias con varias GPU. Dask también funciona cuando se utilizan instancias de una sola GPU.
Siga estos pasos para entrenar con Dask:
1. Omite el `distribution` parámetro en tu cuenta [TrainingInput](https://sagemaker.readthedocs.io/en/stable/api/utility/inputs.html)o configúralo en. `FullyReplicated`
1. Al definir los hiperparámetros, establezca `use_dask_gpu_training` en `"true"`.
**importante**
El entrenamiento distribuido con Dask solo admite los formatos de entrada CSV y Parquet. Si utiliza otros formatos de datos, como LIBSVM o PROTOBUF, el trabajo de entrenamiento no se llevará a cabo.
Con datos Parquet, debe guardar los nombres de las columnas como cadenas. Las columnas que tienen nombres de otros tipos de datos no se cargarán.
**importante**
El entrenamiento distribuido con Dask no admite el modo canalización. Si se especifica el modo canalización, el trabajo de entrenamiento no se llevará a cabo.
Hay algunas consideraciones que hay que tener en cuenta a la hora de entrenar la SageMaker IA XGBoost con Dask. Divida los datos en archivos más pequeños. Dask lee cada archivo de Parquet como una partición. Hay un proceso de trabajo Dask para cada GPU. Como resultado, el número de archivos debe ser mayor que el número total de GPUs (número de instancias \$1 número de GPUs por instancia). Tener una gran cantidad de archivos también puede reducir el rendimiento. Para obtener más información, consulte [Dask Best Practices](https://docs.dask.org/en/stable/best-practices.html).
#### Variaciones en la producción
El `tree_method` hiperparámetro especificado determina el algoritmo que se utiliza para el XGBoost entrenamiento. Los métodos de árbol (`approx`, `hist` y `gpu_hist`) son todos aproximados, y utilizan bocetos para el cálculo de cuantiles. Para obtener más información, consulte [Métodos de árbol](https://xgboost.readthedocs.io/en/stable/treemethod.html) en la XGBoost documentación. El boceto es un algoritmo aproximado. Por lo tanto, cabe esperar variaciones en el modelo en función de factores como el número de procesos de trabajo elegidos para el entrenamiento distribuido. La importancia de la variación depende de los datos.
### Inferencia
SageMaker La IA XGBoost admite instancias de CPU y GPU para realizar inferencias. Para obtener información sobre los tipos de instancias para la inferencia, consulte [Tipos de instancias de Amazon SageMaker AI ML](https://aws.amazon.com/sagemaker/pricing/).
# ¿Cómo usar la IA? SageMaker XGBoost
Con la SageMaker IA, puede XGBoost utilizarla como algoritmo o marco integrado. Cuando se usa XGBoost como marco, tiene más flexibilidad y acceso a escenarios más avanzados, ya que puede personalizar sus propios guiones de entrenamiento. En las siguientes secciones se describe cómo usarlo XGBoost con el SDK de SageMaker Python y la input/output interfaz del XGBoost algoritmo. Para obtener información sobre cómo usarlo XGBoost desde la interfaz de usuario clásica de Amazon SageMaker Studio, consulte[SageMaker JumpStart modelos preentrenados](studio-jumpstart.md).
**Topics**
+ [XGBoost Úselo como marco](#xgboost-how-to-framework)
+ [XGBoost Utilícelo como algoritmo integrado](#xgboost-how-to-built-in)
+ [Interfaz de entrada/salida para el algoritmo XGBoost](#InputOutput-XGBoost)
## XGBoost Úselo como marco
XGBoost Utilícelo como marco para ejecutar sus guiones de formación personalizados que puedan incorporar procesamiento de datos adicional en sus trabajos de formación. En el siguiente ejemplo de código, el SDK de SageMaker Python proporciona la XGBoost API como marco. Esto funciona de forma similar a la forma en que la SageMaker IA proporciona otro marco APIs TensorFlow, como MXNet, y PyTorch.
```
import boto3
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput
# initialize hyperparameters
hyperparameters = {
"max_depth":"5",
"eta":"0.2",
"gamma":"4",
"min_child_weight":"6",
"subsample":"0.7",
"verbosity":"1",
"objective":"reg:squarederror",
"num_round":"50"}
# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-framework'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-framework')
# construct a SageMaker AI XGBoost estimator
# specify the entry_point to your xgboost training script
estimator = XGBoost(entry_point = "your_xgboost_abalone_script.py",
framework_version='1.7-1',
hyperparameters=hyperparameters,
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.m5.2xlarge',
output_path=output_path)
# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)
# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})
```
Para ver un end-to-end ejemplo del uso de la SageMaker IA XGBoost como marco, consulte [Regresión con Amazon SageMaker AI XGBoost](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_abalone_dist_script_mode.html).
## XGBoost Utilícelo como algoritmo integrado
Utilice el algoritmo XGBoost integrado para crear un contenedor de XGBoost entrenamiento, como se muestra en el siguiente ejemplo de código. Puedes detectar automáticamente el URI de la imagen del algoritmo XGBoost integrado mediante la `image_uris.retrieve` API de SageMaker IA. Si utilizas la versión 1 [del SDK de Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), usa la `get_image_uri` API. Para asegurarse de que la API de `image_uris.retrieve` encuentra el URI correcto, consulte [Common parameters for built-in algorithms](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-algo-docker-registry-paths.html). A continuación, `xgboost` consulte la lista completa de imágenes de algoritmos integrados URIs y regiones disponibles.
Tras especificar el URI de la XGBoost imagen, utilice el XGBoost contenedor para crear un estimador mediante la API SageMaker AI Estimator e inicie un trabajo de formación. Este modo de algoritmo XGBoost integrado no incorpora tu propio guion de XGBoost entrenamiento y se ejecuta directamente en los conjuntos de datos de entrada.
**importante**
Cuando recuperes el URI de la XGBoost imagen de SageMaker IA, no utilices `:latest` ni `:1` para la etiqueta URI de la imagen. Debe especificar uno de ellos [Versiones compatibles](xgboost.md#xgboost-supported-versions) para elegir el XGBoost contenedor SageMaker administrado por IA con la versión de XGBoost paquete nativa que desee usar. Para encontrar la versión del paquete migrada a los XGBoost contenedores de SageMaker IA, consulte las [rutas de registro y el código de ejemplo de Docker](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html). A continuación Región de AWS, elige la tuya y navega hasta la sección **XGBoost(algoritmo)**.
```
import sagemaker
import boto3
from sagemaker import image_uris
from sagemaker.session import Session
from sagemaker.inputs import TrainingInput
# initialize hyperparameters
hyperparameters = {
"max_depth":"5",
"eta":"0.2",
"gamma":"4",
"min_child_weight":"6",
"subsample":"0.7",
"objective":"reg:squarederror",
"num_round":"50"}
# set an output path where the trained model will be saved
bucket = sagemaker.Session().default_bucket()
prefix = 'DEMO-xgboost-as-a-built-in-algo'
output_path = 's3://{}/{}/{}/output'.format(bucket, prefix, 'abalone-xgb-built-in-algo')
# this line automatically looks for the XGBoost image URI and builds an XGBoost container.
# specify the repo_version depending on your preference.
xgboost_container = sagemaker.image_uris.retrieve("xgboost", region, "1.7-1")
# construct a SageMaker AI estimator that calls the xgboost-container
estimator = sagemaker.estimator.Estimator(image_uri=xgboost_container,
hyperparameters=hyperparameters,
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='ml.m5.2xlarge',
volume_size=5, # 5 GB
output_path=output_path)
# define the data type and paths to the training and validation datasets
content_type = "libsvm"
train_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'train'), content_type=content_type)
validation_input = TrainingInput("s3://{}/{}/{}/".format(bucket, prefix, 'validation'), content_type=content_type)
# execute the XGBoost training job
estimator.fit({'train': train_input, 'validation': validation_input})
```
Para obtener más información sobre cómo configurarlo XGBoost como algoritmo integrado, consulta los siguientes ejemplos de cuadernos.
+ [Capacitación puntual gestionada para XGBoost](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_managed_spot_training.html)
+ [Regresión con Amazon SageMaker AI XGBoost (entrada de Parquet)](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/xgboost_abalone/xgboost_parquet_input_training.html)
## Interfaz de entrada/salida para el algoritmo XGBoost
La potenciación de gradientes funciona en los datos tabulares, con las filas que representan observaciones, una columna que representa la variable de destino o la etiqueta, y las columnas restantes que representan las características.
La implementación de SageMaker IA XGBoost admite los siguientes formatos de datos para el entrenamiento y la inferencia:
+ *text/libsvm* (predeterminado)
+ *text/csv*
+ *application/x-parquet*
+ *aplicación/ x-recordio-protobuf*
**nota**
Hay algunos factores que debemos tener en cuenta en relación con la entrada para el entrenamiento y las inferencias:
Para aumentar el rendimiento, le recomendamos que utilice XGBoost el *modo Archivo*, en el que los datos de Amazon S3 se almacenan en los volúmenes de las instancias de entrenamiento.
Para el entrenamiento con entrada en columnas, el algoritmo asume que la variable objetivo (etiqueta) es la primera columna. Para la inferencia, el algoritmo asume que la entrada no dispone de la columna de etiqueta.
En el caso de los datos CSV, la entrada no debe tener un registro de encabezado.
Para el entrenamiento con LIBSVM, el algoritmo asume que las columnas posteriores a la columna de etiqueta contienen los pares de valores de índice basados en cero para las características. Así pues, cada fila tiene el formato :