Acelere o treinamento do modelo de aprendizado profundo em até 35% com o Amazon SageMaker Smart Sifting

Republicado por Platão

seguidores: 0

No atual cenário de rápida evolução da inteligência artificial, os modelos de aprendizagem profunda encontraram-se na vanguarda da inovação, com aplicações que abrangem visão computacional (CV), processamento de linguagem natural (PNL) e sistemas de recomendação. No entanto, o custo crescente associado à formação e ao aperfeiçoamento destes modelos representa um desafio para as empresas. Esse custo é impulsionado principalmente pelo grande volume de dados usados no treinamento de modelos de aprendizagem profunda. Hoje, modelos grandes são frequentemente treinados em terabytes de dados e podem levar semanas para serem treinados, mesmo com GPU ou Treinamento AWShardware baseado em. Normalmente, os clientes contam com técnicas e otimizações que melhoram a eficiência do loop de treinamento de um modelo, como kernels ou camadas otimizadas, treinamento de precisão mista ou recursos como o Amazon Sage Maker bibliotecas de treinamento distribuídas. No entanto, hoje há menos foco na eficiência dos próprios dados de treinamento. Nem todos os dados contribuem igualmente para o processo de aprendizagem durante o treinamento do modelo: uma proporção significativa dos recursos computacionais pode ser gasta no processamento de exemplos simples que não contribuem substancialmente para a precisão geral do modelo.

Os clientes tradicionalmente contam com técnicas de pré-processamento, como aumento ou redução da resolução e desduplicação, para refinar e melhorar a qualidade das informações de seus dados. Essas técnicas podem ajudar, mas geralmente consomem muito tempo, exigem experiência especializada em ciência de dados e, às vezes, podem ser mais arte do que ciência. Os clientes muitas vezes também contam com conjuntos de dados selecionados, como RefinadoWeb, para melhorar o desempenho dos seus modelos; no entanto, esses conjuntos de dados nem sempre são totalmente de código aberto e geralmente têm finalidade mais geral e não estão relacionados ao seu caso de uso específico.

De que outra forma você pode superar essa ineficiência relacionada a amostras de dados com pouca informação durante o treinamento do modelo?

Temos o prazer de anunciar uma prévia pública da peneiração inteligente, um novo recurso do SageMaker que pode reduzir o custo de treinamento de modelos de aprendizagem profunda em até 35%. A peneiração inteligente é uma nova técnica de eficiência de dados que analisa ativamente suas amostras de dados durante o treinamento e filtra as amostras que são menos informativas para o modelo. Ao treinar em um subconjunto menor de dados apenas com as amostras que mais contribuem para a convergência do modelo, o treinamento total e o custo diminuem com mínimo ou nenhum impacto na precisão. Além disso, como o recurso opera on-line durante o treinamento do modelo, a filtragem inteligente não requer alterações nos dados upstream ou no pipeline de treinamento downstream.

Neste post, abordamos os seguintes tópicos:

O novo recurso de peneiração inteligente no SageMaker e como ele funciona
Como usar a peneiração inteligente com cargas de trabalho de treinamento PyTorch

Você também pode verificar nossa documentação e cadernos de amostra para obter recursos adicionais sobre como começar a usar a peneiração inteligente.

Como funciona a peneiração inteligente do SageMaker

Começamos esta postagem com uma visão geral de como o recurso de peneiração inteligente pode acelerar o treinamento de seu modelo no SageMaker.

A tarefa da peneiração inteligente é filtrar seus dados de treinamento durante o processo de treinamento e alimentar o modelo apenas com as amostras mais informativas. Durante um treinamento típico com PyTorch, os dados são enviados iterativamente em lotes para o loop de treinamento e para dispositivos aceleradores (por exemplo, GPUs ou chips Trainium) pelo Carregador de dados PyTorch. A filtragem inteligente é implementada neste estágio de carregamento de dados e, portanto, é independente de qualquer pré-processamento de dados upstream em seu pipeline de treinamento.

A peneiração inteligente usa seu modelo e uma função de perda especificada pelo usuário para fazer uma passagem avaliativa de cada amostra de dados à medida que ela é carregada. Amostras com alta perda impactarão materialmente o treinamento do modelo e, portanto, serão usadas no treinamento; amostras de dados com perda relativamente baixa são postas de lado e excluídas do treinamento.

Uma entrada importante para a peneiração inteligente é a proporção de dados a serem excluídos: por exemplo, ao definir a proporção para 33% (beta_value=0.5), as amostras aproximadamente no terço inferior da perda de cada lote serão excluídas do treinamento. Quando amostras de alta perda suficientes são identificadas para completar um lote, os dados são enviados através do loop de treinamento completo e o modelo aprende e treina normalmente. Você não precisa fazer nenhuma alteração em seu ciclo de treinamento quando a peneiração inteligente estiver ativada.

O diagrama a seguir ilustra esse fluxo de trabalho.

Ao incluir apenas um subconjunto dos seus dados de treinamento, a peneiração inteligente reduz o tempo e a computação necessários para treinar o modelo. Em nossos testes, alcançamos uma redução de quase 40% no tempo e custo total de treinamento. Com a triagem inteligente de dados, pode haver impacto mínimo ou nenhum impacto na precisão do modelo porque as amostras excluídas tiveram perdas relativamente baixas para o modelo. Na tabela a seguir, incluímos um conjunto de resultados experimentais que demonstram a melhoria de desempenho possível com a peneiração inteligente SageMaker.

Na tabela, a coluna % aceita indica a proporção de dados incluídos e usados no ciclo de treinamento. Aumentar esse parâmetro ajustável diminui o custo (conforme demonstrado na coluna % de economia de IMR), mas também pode afetar a precisão. A configuração apropriada para% aceito depende do seu conjunto de dados e modelo; você deve experimentar e ajustar esse parâmetro para obter o melhor equilíbrio entre custo reduzido e impacto na precisão.

Visão geral da solução

Nas seções a seguir, veremos um exemplo prático de como ativar a peneiração inteligente com um trabalho de treinamento PyTorch no SageMaker. Se quiser começar rapidamente, você pode pular para o Exemplos de PyTorch ou PyTorch Lightning.

Pré-requisitos

Presumimos que você já saiba como treinar um modelo usando PyTorch ou PyTorch Lightning usando o SageMaker Python SDK e a classe Estimator usando SageMaker Deep Learning Containers para treinamento. Caso contrário, consulte Usando o SDK Python do SageMaker antes de continuar.

Comece com a peneiração inteligente SageMaker

Em um trabalho de treinamento típico do PyTorch, você inicializa o treinamento do PyTorch Carregador de dados com seu conjunto de dados e outros parâmetros necessários, que fornece lotes de entrada à medida que o treinamento avança. Para permitir a triagem inteligente dos seus dados de treinamento, você usará um novo DataLoader classe: smart_sifting.dataloader.sift_dataloader.SiftingDataloader. Esta classe é usada como um wrapper sobre seu PyTorch existente DataLoader e o processo de treinamento usará, em vez disso, SiftingDataloader para obter lotes de entrada. O SiftingDataLoader obtém o lote de entrada do seu PyTorch original DataLoader, avalia a importância das amostras no lote e constrói um lote peneirado com amostras de alta perda, que são então passadas para a etapa de treinamento. O wrapper se parece com o seguinte código:

from smart_sifting.dataloader.sift_dataloader import SiftingDataloader train_dataloader = SiftingDataloader( sift_config = sift_config, orig_dataloader=DataLoader(self.train, self.batch_size, shuffle=True), loss_impl=BertLoss(), model=self.model
)

A SiftingDataloader requer alguns parâmetros adicionais para analisar seus dados de treinamento, que você pode especificar através do sift_config parâmetro. Primeiro, crie um smart_sifting.sift_config.sift_configs.RelativeProbabilisticSiftConfig objeto. Este objeto contém o configurável e necessário beta_value e loss_history_length, que definem respectivamente a proporção de amostras a manter e a janela de amostras a incluir na avaliação da perda relativa. Observe que, como a peneiração inteligente usa seu modelo para definir a importância da amostra, pode haver implicações negativas se usarmos um modelo com pesos completamente aleatórios. Em vez disso, você pode usar loss_based_sift_config e de um sift_delay para atrasar o processo de peneiração até que os pesos dos parâmetros no modelo sejam atualizados além dos valores aleatórios. (Para mais detalhes, consulte Aplique a triagem inteligente ao seu roteiro de treinamento.) No código a seguir, definimos sift_config e especificar beta_value e loss_history_length, bem como atrasar o início da peneiração usando loss_based_sift_config:

from smart_sifting.sift_config.sift_configs import RelativeProbabilisticSiftConfig, LossConfig, SiftingBaseConfig sift_config = RelativeProbabilisticSiftConfig( beta_value=3, loss_history_length=500, loss_based_sift_config=LossConfig( sift_config=SiftingBaseConfig(sift_delay=10) )
)

Em seguida, você também deve incluir um loss_impl parâmetro no SiftingDataloader objeto. A peneiração inteligente funciona em nível de amostra individual e é crucial ter acesso a um método de cálculo de perdas para determinar a importância da amostra. Você deve implementar um método de peneiração de perda que retorne um tensor nx1, que contém valores de perda de n amostras. Normalmente, você especifica o mesmo método de perda usado pelo seu model durante o treinamento. Finalmente, inclua um ponteiro para o seu modelo no SiftingDataloader objeto, que é usado para avaliar amostras antes de serem incluídas no treinamento. Veja o seguinte código:

from smart_sifting.sift_config.sift_configs import RelativeProbabilisticSiftConfig, LossConfig, SiftingBaseConfig ## Defining Sift loss
class SiftBertLoss(Loss): # 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]) ....
.... train_dataloader = SiftingDataloader( sift_config = sift_config, orig_dataloader=DataLoader(self.train, self.batch_size, shuffle=True), loss_impl=SiftBertLoss(), model=self.model
)

O código a seguir mostra um exemplo completo de ativação da peneiração inteligente com um trabalho de treinamento de BERT existente:

from smart_sifting.dataloader.sift_dataloader import SiftingDataloader
from smart_sifting.loss.abstract_sift_loss_module import Loss
from smart_sifting.sift_config.sift_configs import RelativeProbabilisticSiftConfig, LossConfig, SiftingBaseConfig
...
...
... ## Defining Sift loss
class SiftBertLoss(Loss): # 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]) .... .... .... sift_config = RelativeProbabilisticSiftConfig( beta_value=3, loss_history_length=500, loss_based_sift_config=LossConfig( sift_config=SiftingBaseConfig(sift_delay=10) )
) train_dataloader = SiftingDataloader( sift_config = sift_config, orig_dataloader=DataLoader(self.train, self.batch_size, shuffle=True), loss_impl=SiftBertLoss(), model=self.model
) ...... # use train_dataloader in the rest of the training logic.

Conclusão

Nesta postagem, exploramos a visualização pública da peneiração inteligente, um novo recurso do SageMaker que pode reduzir os custos de treinamento do modelo de aprendizagem profunda em até 35%. Esse recurso melhora a eficiência dos dados durante o treinamento, filtrando amostras de dados menos informativas. Ao incluir apenas os dados mais impactantes para a convergência do modelo, você pode reduzir significativamente o tempo e as despesas de treinamento, ao mesmo tempo que mantém a precisão. Além do mais, ele se integra perfeitamente aos processos existentes, sem exigir alterações nos dados ou no pipeline de treinamento.

Para se aprofundar na peneiração inteligente do SageMaker, explorar como ela funciona e implementá-la com cargas de trabalho de treinamento PyTorch, confira nosso documentação e cadernos de amostra e comece com esse novo recurso.

Sobre os autores

Robert Van Dusen é gerente de produto sênior da Amazon SageMaker. Ele lidera estruturas, compiladores e técnicas de otimização para treinamento de aprendizado profundo.

Acelere o treinamento do modelo de aprendizado profundo em até 35% com a peneiração inteligente do Amazon SageMaker | Inteligência de dados PlatoBlockchain da Amazon Web Services. Pesquisa vertical. Ai. K Lokesh Kumar Reddy é engenheiro sênior da equipe Amazon Applied AI. Ele está focado em técnicas eficientes de treinamento de ML e na construção de ferramentas para melhorar sistemas de IA conversacional. Nas horas vagas ele gosta de buscar novas culturas, novas experiências e de se manter atualizado com as últimas tendências tecnológicas.

Acelere o treinamento do modelo de aprendizado profundo em até 35% com a peneiração inteligente do Amazon SageMaker | Inteligência de dados PlatoBlockchain da Amazon Web Services. Pesquisa vertical. Ai. Abhishek Dan é gerente de desenvolvimento sênior na equipe de IA aplicada da Amazon e trabalha com aprendizado de máquina e sistemas de IA conversacional. Ele é apaixonado por tecnologias de IA e trabalha na intersecção entre Ciência e Engenharia no avanço das capacidades dos sistemas de IA para criar interações homem-computador mais intuitivas e contínuas. Atualmente, ele está criando aplicativos em grandes modelos de linguagem para impulsionar a eficiência e melhorias de CX para a Amazon.