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.
# Refinación de datos durante el entrenamiento con Amazon SageMaker Smart Sifting
SageMaker El tamizado inteligente es una capacidad de SageMaker entrenamiento que ayuda a mejorar la eficiencia de los conjuntos de datos de entrenamiento y a reducir el tiempo y el costo total del entrenamiento.
Los modelos modernos de aprendizaje profundo, como los modelos de lenguaje de gran tamaño (LLMs) o los modelos de transformación visual, suelen requerir conjuntos de datos masivos para lograr una precisión aceptable. Por ejemplo, LLMs a menudo se requieren billones de fichas o petabytes de datos para converger. El tamaño creciente de los conjuntos de datos de entrenamiento, junto con el tamaño de los state-of-the-art modelos, pueden aumentar el tiempo de procesamiento y el costo del entrenamiento de los modelos.
De manera invariable, las muestras de un conjunto de datos no contribuyen por igual al proceso de aprendizaje durante el entrenamiento del modelo. Una proporción importante de los recursos computacionales aprovisionados durante el entrenamiento podría dedicarse a procesar muestras sencillas que no contribuyen de manera considerable a la exactitud general de un modelo. Lo ideal sería que los conjuntos de datos de entrenamiento solo incluyeran muestras que realmente mejoren la convergencia del modelo. El filtrado de los datos menos útiles puede reducir el tiempo de entrenamiento y los costos de computación. Sin embargo, la identificación de los datos menos útiles puede resultar difícil y arriesgado. Es prácticamente difícil identificar qué ejemplos son menos informativos antes del entrenamiento, y la exactitud del modelo puede verse afectada si se excluyen ejemplos incorrectos o demasiados ejemplos.
El filtrado inteligente de los datos con Amazon SageMaker AI puede ayudar a reducir el tiempo y los costes de formación al mejorar la eficiencia de los datos. El algoritmo de filtrado SageMaker inteligente evalúa el valor de pérdida de cada dato durante la fase de carga de datos de un trabajo de formación y excluye las muestras que son menos informativas para el modelo. Al utilizar datos refinados para el entrenamiento, se reducen el tiempo y el costo totales del entrenamiento del modelo, ya que se eliminan las transferencias innecesarias hacia adelante y hacia atrás de los datos que no mejoran. Por lo tanto, el impacto en la exactitud del modelo es mínimo o nulo.
SageMaker El filtrado inteligente está disponible a través de SageMaker Training Deep Learning Containers (DLCs) y admite PyTorch cargas de trabajo a través del. PyTorch `DataLoader` Solo se necesitan unas pocas líneas de código para implementar el tamizado SageMaker inteligente y no es necesario cambiar los flujos de trabajo actuales de formación o procesamiento de datos.
**Topics**
+ [Cómo funciona el tamizado SageMaker inteligente](train-smart-sifting-how-it-works.md)
+ [Marcos y AWS regiones compatibles](train-smart-sifting-what-is-supported.md)
+ [SageMaker selección inteligente en tu guion de entrenamiento](train-smart-sifting-apply-to-script.md)
+ [Resolución de problemas](train-smart-sifting-best-prac-considerations-troubleshoot.md)
+ [Seguridad en el tamizado inteligente SageMaker](train-smart-sifting-security.md)
+ [SageMaker referencia del SDK de Python para tamizado inteligente](train-smart-sifting-pysdk-reference.md)
+ [SageMaker notas de publicación sobre el tamizado inteligente](train-smart-sifting-release-notes.md)
# Cómo funciona el tamizado SageMaker inteligente
El objetivo del tamizado SageMaker inteligente es filtrar los datos de entrenamiento durante el proceso de entrenamiento y añadir al modelo únicamente muestras más informativas. Durante un entrenamiento normal PyTorch, los datos se envían de forma iterativa en lotes al circuito de entrenamiento y a los dispositivos aceleradores (como GPUs los chips Trainium). [PyTorch`DataLoader`](https://pytorch.org/docs/stable/data.html) SageMaker El filtrado inteligente se implementa en esta fase de carga de datos y, por lo tanto, es independiente de cualquier procesamiento previo de los datos que se esté realizando en el proceso de entrenamiento. SageMaker El tamizado inteligente utiliza su modelo y su función de pérdida especificada por el usuario para realizar una transferencia evaluativa de cada muestra de datos a medida que se carga. Las muestras que devuelven valores de *pérdida baja* tienen un impacto menor en el aprendizaje del modelo y, por lo tanto, se excluyen del entrenamiento, dado que ya es *fácil* para el modelo hacer la predicción adecuada sobre ellas con una alta confianza. Mientras tanto, esas muestras con pérdidas relativamente altas son las que el modelo aún necesita aprender, por lo que se conservan para el entrenamiento. Una entrada clave que puede configurar para el filtrado SageMaker inteligente es la proporción de datos que se van a excluir. Por ejemplo, al establecer la proporción en un 25 %, se excluyen del entrenamiento las muestras distribuidas en el cuartil más bajo de la distribución de la pérdida (tomadas de un número de muestras anteriores especificado por el usuario). Las muestras con pérdida alta se acumulan en un lote de datos mejorado. El lote de datos mejorado se envía al ciclo de entrenamiento (pasada hacia adelante y hacia atrás), y el modelo aprende y se entrena sobre el lote de datos mejorado.
El siguiente diagrama muestra una descripción general de cómo está diseñado el algoritmo de tamizado SageMaker inteligente.
![\[Diagrama de arquitectura que muestra cómo funciona el tamizado SageMaker inteligente durante el entrenamiento a medida que se cargan los datos.\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/images/smartsifting-arch.png)
En resumen, el tamizado SageMaker inteligente funciona durante el entrenamiento a medida que se cargan los datos. El algoritmo de filtrado SageMaker inteligente calcula las pérdidas entre los lotes y filtra los datos que no mejoran antes de avanzar y retroceder en cada iteración. A continuación, el lote de datos refinado se utiliza para la pasada hacia delante y hacia atrás.
**nota**
El filtrado inteligente de los datos en la SageMaker IA utiliza pases directos adicionales para analizar y filtrar los datos de entrenamiento. A su vez, hay menos pasadas hacia atrás, ya que los datos menos impactantes se excluyen de su trabajo de entrenamiento. Por este motivo, los modelos que tienen pasadas hacia atrás largas o caras obtienen los mayores beneficios de eficiencia cuando utilizan la selección inteligente. Por otro lado, si la pasada hacia delante del modelo tarda más que la pasada hacia atrás, la sobrecarga podría aumentar el tiempo total de entrenamiento. Para medir el tiempo empleado en cada pasada, puede realizar un trabajo de entrenamiento de piloto y recopilar registros que registren el tiempo que tardan los procesos. Considere también la posibilidad de utilizar SageMaker Profiler, que proporciona herramientas de creación de perfiles y una aplicación de interfaz de usuario. Para obtener más información, consulte [Amazon SageMaker Profiler](train-use-sagemaker-profiler.md).
SageMaker El filtrado inteligente funciona para trabajos de formación PyTorch basados en el clásico paralelismo de datos distribuidos, que permite crear réplicas de modelos en cada unidad de trabajo de la GPU y su rendimiento. `AllReduce` Funciona con PyTorch DDP y la biblioteca paralela de datos distribuidos de SageMaker IA.
# Marcos y AWS regiones compatibles
Antes de utilizar el cargador de datos de filtrado SageMaker inteligente, compruebe si el marco que ha elegido es compatible, si los tipos de instancia están disponibles en su AWS cuenta y si su AWS cuenta se encuentra en una de las AWS regiones compatibles.
**nota**
SageMaker El filtrado inteligente permite el entrenamiento de PyTorch modelos con el paralelismo de datos tradicional y el paralelismo de datos distribuidos, lo que permite crear réplicas de modelos en todos los empleados de la GPU y utilizar esta operación. `AllReduce` No funciona con las técnicas de paralelismo de modelos, incluido el paralelismo de datos con particiones. Como el tamizado SageMaker inteligente funciona en los trabajos de paralelismo de datos, asegúrate de que el modelo que entrenes quepa en la memoria de cada GPU.
## Marcos admitidos
SageMaker smart sifting es compatible con los siguientes marcos de aprendizaje profundo y está disponible a través de AWS Deep Learning Containers.
**Topics**
+ [PyTorch](#train-smart-sifting-supported-frameworks-pytorch)
### PyTorch
| Marcos | Versión de marco | URI de contenedor de aprendizaje profundo |
| --- | --- | --- |
| PyTorch | 2.1.0 | *763104351884*.dkr.ecr. *region*.amazonaws.com/pytorch-training:2.1.0-gpu-py310-cu121-ubuntu20.04-sagemaker |
Para obtener más información sobre los contenedores prediseñados, consulte [SageMaker AI Framework Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) en el * GitHub repositorio de AWS Deep Learning Containers*.
## Regiones de AWS
Los [contenedores empaquetados con la biblioteca de SageMaker filtrado inteligente](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-training-compiler-containers) están disponibles en el Regiones de AWS lugar donde se encuentran en servicio los [AWS Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
## Tipos de instancias
Puede utilizar el tamizado SageMaker inteligente para cualquier trabajo de PyTorch formación en cualquier tipo de instancia. Le recomendamos que utilice instancias P4d, P4de o P5.
# SageMaker selección inteligente en tu guion de entrenamiento
La biblioteca de filtrado SageMaker inteligente se incluye en el [marco de SageMaker IA DLCs](train-smart-sifting-what-is-supported.md#train-smart-sifting-supported-frameworks) como una biblioteca complementaria. Proporciona una lógica de filtrado para las muestras de entrenamiento que tienen un impacto relativamente menor en el entrenamiento del modelo, y el modelo puede alcanzar la exactitud del modelo deseada con menos muestras de entrenamiento en comparación con el entrenamiento del modelo con muestras de datos completas.
Para obtener información sobre cómo implementar la herramienta de selección inteligente en su script de entrenamiento, elija una de las siguientes opciones en función del marco que utilice.
**Topics**
+ [Aplica un tamizado SageMaker inteligente a tu script PyTorch](train-smart-sifting-apply-to-pytorch-script.md)
+ [Aplica un tamizado SageMaker inteligente a tu guion de Hugging Face Transformers](train-smart-sifting-apply-to-hugging-face-transformers-script.md)
# Aplica un tamizado SageMaker inteligente a tu script PyTorch
Estas instrucciones muestran cómo habilitar el tamizado SageMaker inteligente con tu guion de entrenamiento.
1. Configure la interfaz de cribado SageMaker inteligente.
La biblioteca de tamizado SageMaker inteligente implementa una técnica de muestreo basada en el umbral de pérdida relativa que ayuda a filtrar las muestras con un menor impacto en la reducción del valor de la pérdida. El algoritmo de tamizado SageMaker inteligente calcula el valor de pérdida de cada muestra de datos de entrada mediante una pasada directa y calcula su percentil relativo respecto a los valores de pérdida de los datos anteriores.
Los dos parámetros siguientes son los que debe especificar para la clase `RelativeProbabilisticSiftConfig` para crear un objeto de configuración de selección.
+ Especifique la proporción de los datos que se deben utilizar para el entrenamiento con el parámetro `beta_value`.
+ Especifique el número de muestras utilizadas en la comparación con el parámetro `loss_history_length`.
En el siguiente ejemplo de código, se muestra la configuración de un objeto de la clase `RelativeProbabilisticSiftConfig`.
```
from smart_sifting.sift_config.sift_configs import (
RelativeProbabilisticSiftConfig
LossConfig
SiftingBaseConfig
)
sift_config=RelativeProbabilisticSiftConfig(
beta_value=0.5,
loss_history_length=500,
loss_based_sift_config=LossConfig(
sift_config=SiftingBaseConfig(sift_delay=0)
)
)
```
Para obtener más información sobre el `loss_based_sift_config` parámetro y las clases relacionadas, consulte [SageMaker módulos de configuración de tamizado inteligente](train-smart-sifting-pysdk-reference.md#train-smart-sifting-pysdk-base-config-modules) la sección de referencia del SDK de Python para filtrado SageMaker inteligente.
El objeto `sift_config` del ejemplo de código anterior se utiliza en el paso 4 para configurar la clase `SiftingDataloader`.
1. (Opcional) Configure una clase de transformación por lotes de filtrado SageMaker inteligente.
Los diferentes casos de uso de entrenamiento requieren diferentes formatos de datos de entrenamiento. Dada la variedad de formatos de datos, el algoritmo de tamizado SageMaker inteligente debe identificar cómo realizar el tamizado en un lote en particular. Para solucionar este problema, el tamizado SageMaker inteligente proporciona un módulo de transformación por lotes que ayuda a convertir los lotes en formatos estandarizados que se pueden tamizar de manera eficiente.
1. SageMaker El tamizado inteligente gestiona la transformación por lotes de los datos de entrenamiento en los siguientes formatos: listas de Python, diccionarios, tuplas y tensores. Para estos formatos de datos, el tamizado SageMaker inteligente gestiona automáticamente la conversión del formato de datos por lotes, y puedes saltarte el resto de este paso. Si omite este paso, en el paso 4 de la configuración de `SiftingDataloader`, deje el parámetro `batch_transforms` de `SiftingDataloader` en su valor predeterminado, que es `None`.
1. Si el conjunto de datos no se encuentra en este formato, debe continuar con el resto de este paso para crear una transformación por lotes personalizada mediante `SiftingBatchTransform`.
En los casos en los que el conjunto de datos no esté en uno de los formatos compatibles con el SageMaker filtrado inteligente, es posible que se produzcan errores. Estos errores de formato de datos se pueden resolver agregando el parámetro `batch_format_index` o `batch_transforms` a la clase `SiftingDataloader`, que configuró en el paso 4. A continuación se muestran ejemplos de errores debidos a un formato de datos incompatible y sus resoluciones.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/train-smart-sifting-apply-to-pytorch-script.html)
Para resolver los problemas antes mencionados, debe crear una clase de transformación por lotes personalizada mediante el módulo `SiftingBatchTransform`. Una clase de transformación por lotes debe constar de un par de funciones de transformación y transformación inversa. El par de funciones convierte el formato de datos a un formato que el algoritmo de filtrado SageMaker inteligente pueda procesar. Tras crear una clase de transformación por lotes, la clase devuelve un objeto `SiftingBatch` que pasará a la clase `SiftingDataloader` en el paso 4.
Los siguientes son ejemplos de clases de transformación por lotes personalizadas del módulo `SiftingBatchTransform`.
+ Un ejemplo de implementación de transformación por lotes de listas personalizada con filtrado SageMaker inteligente para los casos en los que el fragmento del cargador de datos contiene entradas, máscaras y etiquetas.
```
from typing import Any
import torch
from smart_sifting.data_model.data_model_interface import SiftingBatchTransform
from smart_sifting.data_model.list_batch import ListBatch
class ListBatchTransform(SiftingBatchTransform):
def transform(self, batch: Any):
inputs = batch[0].tolist()
labels = batch[-1].tolist() # assume the last one is the list of labels
return ListBatch(inputs, labels)
def reverse_transform(self, list_batch: ListBatch):
a_batch = [torch.tensor(list_batch.inputs), torch.tensor(list_batch.labels)]
return a_batch
```
+ Un ejemplo de implementación de transformación por lotes de listas personalizada con filtrado SageMaker inteligente para los casos en los que no se necesitan etiquetas para la transformación inversa.
```
class ListBatchTransformNoLabels(SiftingBatchTransform):
def transform(self, batch: Any):
return ListBatch(batch[0].tolist())
def reverse_transform(self, list_batch: ListBatch):
a_batch = [torch.tensor(list_batch.inputs)]
return a_batch
```
+ Un ejemplo de implementación por lotes de tensores personalizada con filtrado SageMaker inteligente para los casos en los que el fragmento del cargador de datos contiene entradas, máscaras y etiquetas.
```
from typing import Any
from smart_sifting.data_model.data_model_interface import SiftingBatchTransform
from smart_sifting.data_model.tensor_batch import TensorBatch
class TensorBatchTransform(SiftingBatchTransform):
def transform(self, batch: Any):
a_tensor_batch = TensorBatch(
batch[0], batch[-1]
) # assume the last one is the list of labels
return a_tensor_batch
def reverse_transform(self, tensor_batch: TensorBatch):
a_batch = [tensor_batch.inputs, tensor_batch.labels]
return a_batch
```
Tras crear una clase de transformación por lotes implementada `SiftingBatchTransform`, utilice esta clase en el paso 4 para configurar la clase `SiftingDataloader`. En el resto de esta guía se presupone que se ha creado una clase `ListBatchTransform`. En el paso 4, esta clase se pasa a `batch_transforms`.
1. Cree una clase para implementar la interfaz de filtrado SageMaker inteligente. `Loss` En este tutorial se presupone que la clase se llama `SiftingImplementedLoss`. Al configurar esta clase, le recomendamos que utilice la misma función de pérdida en el ciclo de entrenamiento del modelo. Siga los siguientes subpasos para crear una clase implementada para el tamizado SageMaker `Loss` inteligente.
1. SageMaker El tamizado inteligente calcula un valor de pérdida para cada muestra de datos de entrenamiento, en lugar de calcular un valor de pérdida único para un lote. Para garantizar que el tamizado SageMaker inteligente utilice la misma lógica de cálculo de pérdidas, cree una función de smart-sifting-implemented pérdida mediante el `Loss` módulo de tamizado SageMaker inteligente que utilice su función de pérdida y calcule las pérdidas por muestra de entrenamiento.
**sugerencia**
SageMaker El algoritmo de tamizado inteligente se ejecuta en todas las muestras de datos, no en todo el lote, por lo que debe añadir una función de inicialización para configurar la función de PyTorch pérdida sin ninguna estrategia de reducción.
```
class SiftingImplementedLoss(Loss):
def __init__(self):
self.loss = torch.nn.CrossEntropyLoss(reduction='none')
```
Esto se también se muestra en el siguiente ejemplo.
1. Defina una función de pérdida que acepte el `original_batch` modelo (o `transformed_batch` si ha configurado una transformación por lotes en el paso 2) y el PyTorch modelo. Al utilizar la función de pérdida especificada sin reducción, el cribado SageMaker inteligente realiza una transferencia directa de cada muestra de datos para evaluar su valor de pérdida.
El código siguiente es un ejemplo de una smart-sifting-implemented `Loss` interfaz denominada`SiftingImplementedLoss`.
```
from typing import Any
import torch
import torch.nn as nn
from torch import Tensor
from smart_sifting.data_model.data_model_interface import SiftingBatch
from smart_sifting.loss.abstract_sift_loss_module import Loss
model=... # a PyTorch model based on torch.nn.Module
class SiftingImplementedLoss(Loss):
# You should add the following initializaztion function
# to calculate loss per sample, not per batch.
def __init__(self):
self.loss_no_reduction = torch.nn.CrossEntropyLoss(reduction='none')
def loss(
self,
model: torch.nn.Module,
transformed_batch: SiftingBatch,
original_batch: Any = None,
) -> torch.Tensor:
device = next(model.parameters()).device
batch = [t.to(device) for t in original_batch] # use this if you use original batch and skipped step 2
# batch = [t.to(device) for t in transformed_batch] # use this if you transformed batches in step 2
# compute loss
outputs = model(batch)
return self.loss_no_reduction(outputs.logits, batch[2])
```
Antes de que el ciclo de entrenamiento llegue a la pasada hacia adelante real, este cálculo de la pérdida de selección se realiza durante la fase de carga de datos, en la que se recupera un lote en cada iteración. A continuación, el valor de pérdida individual se compara con los valores de pérdida anteriores y su percentil relativo se estima según el objeto de `RelativeProbabilisticSiftConfig` que haya configurado en el paso 1.
1. Envuelva el cargador de PyTroch datos según la `SiftingDataloader` clase SageMaker AI.
Por último, utilice todas las clases implementadas de filtrado SageMaker inteligente que configuró en los pasos anteriores para la clase de `SiftingDataloder` configuración de SageMaker IA. Esta clase es un contenedor para. PyTorch [https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader) Al empaquetar PyTorch`DataLoader`, el tamizado SageMaker inteligente se registra para ejecutarse como parte de la carga de datos en cada iteración de un PyTorch trabajo de formación. El siguiente ejemplo de código muestra la implementación del filtrado de datos de SageMaker IA en un. PyTorch `DataLoader`
```
from smart_sifting.dataloader.sift_dataloader import SiftingDataloader
from torch.utils.data import DataLoader
train_dataloader = DataLoader(...) # PyTorch data loader
# Wrap the PyTorch data loader by SiftingDataloder
train_dataloader = SiftingDataloader(
sift_config=sift_config, # config object of RelativeProbabilisticSiftConfig
orig_dataloader=train_dataloader,
batch_transforms=ListBatchTransform(), # Optional, this is the custom class from step 2
loss_impl=SiftingImplementedLoss(), # PyTorch loss function wrapped by the Sifting Loss interface
model=model,
log_batch_data=False
)
```
# Aplica un tamizado SageMaker inteligente a tu guion de Hugging Face Transformers
Hay dos formas de implementar la selección SageMaker inteligente en la clase Transformers. `Trainer`
**nota**
Si usa uno de los formularios PyTorch con el DLCs paquete de SageMaker filtrado inteligente instalado, tenga en cuenta que debe instalar la biblioteca. `transformers` Puedes instalar paquetes adicionales [ampliando DLCs o pasando `requirements.txt` a la](prebuilt-containers-extend.md) clase de lanzador de tareas de formación para PyTorch ([https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)) en el SDK de Python para SageMaker IA.
## Configuración sencilla
La forma más sencilla de implementar el SageMaker filtrado inteligente en la `Trainer` clase Transformers es usar la función. `enable_sifting` Esta función acepta un objeto `Trainer` existente y encapsula el objeto`DataLoader` existente con `SiftingDataloader`. Puede seguir utilizando el mismo objeto de entrenamiento. Consulte el siguiente uso de ejemplo.
```
from smart_sifting.integrations.trainer import enable_sifting
from smart_sifting.loss.abstract_sift_loss_module import Loss
from smart_sifting.sift_config.sift_configs import (
RelativeProbabilisticSiftConfig
LossConfig
SiftingBaseConfig
)
class SiftingImplementedLoss(Loss):
def loss(self, model, transformed_batch, original_batch):
loss_fct = MSELoss(reduction="none") # make sure to set reduction to "none"
logits = model.bert(**original_batch)
return loss_fct(logits, original_batch.get("labels"))
sift_config = RelativeProbabilisticSiftConfig(
beta_value=0.5,
loss_history_length=500,
loss_based_sift_config=LossConfig(
sift_config=SiftingBaseConfig(sift_delay=0)
)
)
trainer = Trainer(...)
enable_sifting(trainer, sift_config, loss=SiftingImplementedLoss()) # updates the trainer with Sifting Loss and config
trainer.train()
```
La clase `SiftingDataloader` es un cargador de datos iterable. El tamaño exacto del conjunto de datos resultante no se conoce de antemano debido al muestreo aleatorio que se realiza durante la selección. Como resultado, `Trainer` de Hugging Face espera el [argumento de entrenamiento de `max_steps`](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.max_steps). Tenga en cuenta que este argumento anula el parámetro de configuración epoch `num_train_epochs`. Si el cargador de datos original también era iterable, o si su entrenamiento utiliza `max_steps` y un solo epoch, `SiftingDataloader` funciona igual que el cargador de datos existente. Si el cargador de datos original no era iterable o no se proporcionó `max_steps`, el entrenador de Hugging Face podría generar un mensaje de error similar al siguiente.
```
args.max_steps must be set to a positive value if dataloader does not have a length,
was -1
```
Para solucionar este problema, la función `enable_sifting` proporciona un parámetro `set_epochs` opcional. Esto permite el entrenamiento con epochs, utilizando el número de épocas proporcionado por el [argumento num\$1train\$1epochs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.num_train_epochs(float,) de la clase `Trainer`, y establece `max_steps` en el número entero máximo del sistema, lo que permite que el entrenamiento avance hasta completar los epochs especificados.
## Configuración personalizada
Para una integración personalizada del cargador de datos de tamizado SageMaker inteligente, puedes utilizar una clase personalizada de Hugging Face. `Trainer` Dentro de cualquier subclase de `Trainer`, la función `get_train_dataloader()` se puede anular para devolver un objeto de la clase `SiftingDataloader` en su lugar. En el caso de los entrenadores personalizados existentes, este enfoque puede ser menos intrusivo, pero requiere cambios de código, en comparación con la opción de configuración sencilla. El siguiente es un ejemplo de implementación de la SageMaker selección inteligente en una clase personalizada de Hugging Face. `Trainer`
```
from smart_sifting.sift_config.sift_configs import (
RelativeProbabilisticSiftConfig
LossConfig
SiftingBaseConfig
)
from smart_sifting.dataloader.sift_dataloader import SiftingDataloader
from smart_sifting.loss.abstract_sift_loss_module import Loss
from smart_sifting.data_model.data_model_interface import SiftingBatch, SiftingBatchTransform
from smart_sifting.data_model.list_batch import ListBatch
class SiftingListBatchTransform(SiftingBatchTransform):
def transform(self, batch: Any):
inputs = batch[0].tolist()
labels = batch[-1].tolist() # assume the last one is the list of labels
return ListBatch(inputs, labels)
def reverse_transform(self, list_batch: ListBatch):
a_batch = [torch.tensor(list_batch.inputs), torch.tensor(list_batch.labels)]
return a_batch
class SiftingImplementedLoss():
# You should add the following initializaztion function
# to calculate loss per sample, not per batch.
def __init__(self):
self.celoss = torch.nn.CrossEntropyLoss(reduction='none')
def loss(
self,
model: torch.nn.Module,
transformed_batch: SiftingBatch,
original_batch: Any = None,
) -> torch.Tensor:
device = next(model.parameters()).device
batch = [t.to(device) for t in original_batch]
# compute loss
outputs = model(batch)
return self.celoss(outputs.logits, batch[2])
class SiftingImplementedTrainer(Trainer):
def get_train_dataloader(self):
dl = super().get_train_dataloader()
sift_config = RelativeProbabilisticSiftConfig(
beta_value=0.5,
loss_history_length=500,
loss_based_sift_config=LossConfig(
sift_config=SiftingBaseConfig(sift_delay=0)
)
)
return SiftingDataloader(
sift_config=sift_config,
orig_dataloader=dl,
batch_transforms=SiftingListBatchTransform(),
loss_impl=SiftingImplementedLoss(),
model=self.model
)
```
Con la clase `Trainer` encapsulada, cree un objeto de la misma de la siguiente manera.
```
trainer = SiftingImplementedTrainer(
model=model,
args=training_args,
train_dataset=small_train_dataset,
eval_dataset=small_eval_dataset
)
trainer.train()
```
# Resolución de problemas
Si surge un error, puede utilice la siguiente lista para intentar solucionar el problema. Si necesitas más ayuda, ponte en contacto con el equipo de SageMaker IA en sm-smart-sifting-feedback@amazon .com.
**Excepciones de la SageMaker biblioteca de selección inteligente**
Utilice la siguiente referencia de las excepciones generadas por la biblioteca de tamizado SageMaker inteligente para solucionar los errores e identificar las causas.
| Nombre de excepción | Description (Descripción) |
| --- | --- |
| SiftConfigValidationException | Se extrae de la biblioteca de filtrado SageMaker inteligente en caso de que falte alguna clave de Config o un tipo de valor no compatible con Sift Key |
| UnsupportedDataFormatException | Se extrae de la biblioteca de SageMaker filtrado inteligente en caso de que no sea compatible con la lógica de filtrado DataFormat |
| LossImplementationNotProvidedException | Se genera en caso de que falte o no se implemente la interfaz de pérdida. |
# Seguridad en el tamizado inteligente SageMaker
Como la biblioteca de cribado SageMaker inteligente ejecuta procesos de eliminación de muestras de entrenamiento menos valiosas, requiere acceso total a los conjuntos de datos de entrenamiento tal como los genera el cargador de datos. Este acceso no es diferente del acceso que ya se proporciona PyTorch en un escenario de entrenamiento normal.
SageMaker El filtrado inteligente tiene un registro incorporado con implicaciones de seguridad. De forma predeterminada, los registros de filtrado SageMaker inteligente son solo registros a nivel de aplicación que contienen métricas, latencias y errores o advertencias de los usuarios. Sin embargo, los usuarios pueden optar por habilitar los registros detallados, que registran datos de lotes completos para mostrar qué muestras se han eliminado de un lote determinado. Estos registros se emiten mediante registradores de Python y la biblioteca no los carga ni almacena en ningún lugar. En el caso de la carga automática de registros a servicios similares CloudWatch o similares, ten en cuenta que el uso de registros detallados puede provocar que se carguen datos de entrenamiento confidenciales fuera de la instancia de entrenamiento.
Más allá del registro mencionado anteriormente, el filtrado SageMaker inteligente no tiene ninguna funcionalidad de red ni interactúa con el sistema de archivos local. Los datos de usuario se almacenan como objetos en la memoria durante todo el tiempo que la biblioteca los utiliza.
# SageMaker referencia del SDK de Python para tamizado inteligente
Esta página proporciona una referencia de los módulos de Python que necesita para aplicar el tamizado SageMaker inteligente a su script de entrenamiento.
## SageMaker módulos de configuración de tamizado inteligente
**`class smart_sifting.sift_config.sift_configs.RelativeProbabilisticSiftConfig()`**
La clase de configuración de tamizado SageMaker inteligente.
**Parámetros**
+ `beta_value` (float): un valor beta (constante). Se utiliza para calcular la probabilidad de seleccionar una muestra para entrenamiento en función del percentil de la pérdida en el historial de valores de pérdida. Si se reduce el valor beta, se disminuye el porcentaje de los datos seleccionados y, al aumentarlo, se obtiene un porcentaje superior de datos seleccionados. No hay un valor mínimo ni máximo para el valor beta, salvo que debe ser un valor positivo. En la siguiente tabla de referencia se proporciona información sobre las tasas de selección con respecto a `beta_value`.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/train-smart-sifting-pysdk-reference.html)
+ `loss_history_length` (int): el número de pérdidas de entrenamiento previas que se almacenarán para el muestreo basado en la pérdida de umbral relativa.
+ `loss_based_sift_config`(dictado o un `LossConfig` objeto): especifique un `LossConfig` objeto que devuelva la configuración de la interfaz SageMaker Smart Sifting Loss.
**`class smart_sifting.sift_config.sift_configs.LossConfig()`**
La clase de configuración para el parámetro `loss_based_sift_config` de la clase `RelativeProbabilisticSiftConfig`.
**Parámetros**
+ `sift_config` (dict o un objeto `SiftingBaseConfig`): especifique un objeto `SiftingBaseConfig` que devuelva un diccionario de configuración base de la selección.
**`class smart_sifting.sift_config.sift_configs.SiftingBaseConfig()`**
La clase de configuración para el parámetro `sift_config` de `LossConfig`.
**Parámetros**
+ `sift_delay` (int): el número de pasos de entrenamiento que hay que esperar antes de empezar la selección. Le recomendamos que empiece la selección después de que todas las capas del modelo tengan una vista suficiente de los datos de entrenamiento. El valor predeterminado es `1000`.
+ `repeat_delay_per_epoch` (bool): especifique si desea retrasar la selección de cada época. El valor predeterminado es `False`.
## SageMaker tamizado inteligente (módulos de transformación por lotes) de datos
`class smart_sifting.data_model.data_model_interface.SiftingBatchTransform`
Un módulo de Python de filtrado SageMaker inteligente para definir cómo realizar la transformación por lotes. Con esto, puedes configurar una clase de transformación por lotes que convierta el formato de datos de tus datos de entrenamiento en `SiftingBatch` formato. SageMaker El tamizado inteligente puede filtrar y acumular datos en este formato en un lote tamizado.
`class smart_sifting.data_model.data_model_interface.SiftingBatch`
Interfaz para definir un tipo de datos por lotes que se puede seleccionar y acumular
`class smart_sifting.data_model.list_batch.ListBatch`
Módulo para realizar un seguimiento de un lote de listas para su selección
`class smart_sifting.data_model.tensor_batch.TensorBatch`
Módulo para realizar un seguimiento de un lote de tensores para su selección.
## SageMaker módulo de implementación de pérdidas por tamizado inteligente
`class smart_sifting.loss.abstract_sift_loss_module.Loss`
Un módulo contenedor para registrar la interfaz de tamizado SageMaker inteligente en la función de pérdida de un PyTorch modelo basado.
## SageMaker módulo contenedor y cargador de datos de cribado inteligente
`class smart_sifting.dataloader.sift_dataloader.SiftingDataloader`
Un módulo contenedor para registrar la interfaz de filtrado SageMaker inteligente en el cargador de datos de un modelo basado. PyTorch
El iterador del cargador de datos de selección principal selecciona las muestras de entrenamiento de un cargador de datos en función de una configuración de selección.
**Parámetros**
+ `sift_config` (dict o un objeto `RelativeProbabilisticSiftConfig`): un objeto `RelativeProbabilisticSiftConfig`.
+ `orig_dataloader`(un PyTorch DataLoader objeto): especifique el objeto PyTorch Dataloader que se va a empaquetar.
+ `batch_transforms`(un `SiftingBatchTransform` objeto): (opcional) Si la transformación predeterminada de la biblioteca de filtrado SageMaker inteligente no admite el formato de datos, debe crear una clase de transformación por lotes mediante el módulo. `SiftingBatchTransform` Este parámetro se usa para pasar la clase de transformación por lotes. Esta clase se utiliza `SiftingDataloader` para convertir los datos a un formato que el algoritmo de SageMaker filtrado inteligente pueda aceptar.
+ `model`(un objeto PyTorch modelo): el modelo original PyTorch
+ `loss_impl`(una función de pérdida de tamizado de`smart_sifting.loss.abstract_sift_loss_module.Loss`): función de pérdida de tamizado que se configura con el `Loss` módulo y envuelve la PyTorch función de pérdida.
+ `log_batch_data` (bool): especifique si desea registrar los datos por lotes. Si está configurada`True`, el tamizado SageMaker inteligente registra los detalles de los lotes que se guardan o se tamizan. Le recomendamos que lo active solo para un trabajo de entrenamiento de pilotos. Cuando se activa el registro, las muestras se cargan en la GPU y se transfieren a la CPU, lo que supone una sobrecarga. El valor predeterminado es `False`.
# SageMaker notas de publicación sobre el tamizado inteligente
Consulte las siguientes notas de la versión para realizar un seguimiento de las últimas actualizaciones de la función de cribado SageMaker inteligente.
## SageMaker notas de la versión de Smart Sifting: 29 de noviembre de 2023
**Nuevas características**
+ Lanzó la biblioteca de tamizado SageMaker inteligente de Amazon en AWS re:Invent 2023.
**Migración a AWS Deep Learning Containers**
+ La biblioteca de filtrado SageMaker inteligente ha superado las pruebas de integración y está disponible en AWS Deep Learning Containers. Para ver una lista completa de los contenedores prediseñados con la biblioteca de SageMaker filtrado inteligente, consulte. [Marcos y AWS regiones compatibles](train-smart-sifting-what-is-supported.md)