Realizar o treinamento incremental (console)Realizar o treinamento incremental (API)

Use o treinamento incremental na Amazon SageMaker

Com o tempo, você pode perceber que um modelo gera uma inferência não tão boa como no passado. Com o treinamento incremental, você pode usar os artefatos de um modelo existente e usar um conjunto de dados expandido para treinar um novo modelo. O treinamento incremental economiza tempo e recursos.

Use o treinamento incremental para:

Treinar um novo modelo usando um conjunto de dados expandido que contenha um padrão subjacente que não tenha sido considerado no treinamento anterior e que tenha resultado em desempenho ruim do modelo.
Usar os artefatos de modelo ou uma parte dos artefatos de um modelo popular publicamente disponível em um trabalho de treinamento. Você não precisa treinar um novo modelo do zero.
Retomar um trabalho de treinamento que foi interrompido.
Treinar várias variantes de um modelo, com diferentes configurações de hiperparâmetros ou usando diferentes conjuntos de dados.

Para obter mais informações sobre trabalhos de treinamento, consulte Treine um modelo com a Amazon SageMaker.

Você pode treinar de forma incremental usando o SageMaker console ou o SDK do Amazon SageMaker Python.

Importante

No momento, apenas três algoritmos integrados oferecem suporte ao treinamento incremental: Detecção de objetos - MXNet, Classificação de imagens - MXNet e Algoritmo de segmentação semântica.

Tópicos

Realizar o treinamento incremental (console)
Realizar o treinamento incremental (API)

Realizar o treinamento incremental (console)

Para concluir este procedimento, você precisa:

O URL do bucket do Amazon Simple Storage Service (Amazon S3) onde você armazenou os dados de treinamento.
O URL do bucket do S3 onde você deseja armazenar o resultado do trabalho.
O caminho do Amazon Elastic Container Registry onde o código de treinamento foi armazenado. Para obter mais informações, consulte Caminhos de registro do Docker e código de exemplo.
A URL do bucket do S3 onde você armazenou os artefatos de modelo que deseja usar no treinamento incremental. Para localizar a URL dos artefatos de modelo, consulte a página de detalhes do trabalho de treinamento usado para criar o modelo. Para encontrar a página de detalhes, no SageMaker console, escolha Inferência, escolha Modelos e, em seguida, escolha o modelo.

Para reiniciar um trabalho de treinamento interrompido, use a URL para os artefatos de modelo armazenados na página de detalhes, como faria com um modelo ou um trabalho de treinamento concluído.

Para realizar o treinamento incremental (console)

Abra o SageMaker console da Amazon em https://console.aws.amazon.com/sagemaker/.
No painel de navegação, escolha Treinamento e Trabalhos de treinamento.
Escolha Criar trabalho de treinamento.
Forneça um nome para o trabalho de treinamento. O nome deve ser exclusivo dentro de uma AWS região em uma AWS conta. O nome do trabalho de treinamento deve ter de 1 a 63 caracteres. Caracteres válidos: a-z, A-Z, 0-9 e . : + = @ _ % - (hífen).
Escolha o algoritmo que você deseja usar. Para obter informações sobre algoritmos, consulte Algoritmos integrados e modelos pré-treinados na Amazon SageMaker.
(Opcional) Para Configuração de recursos, deixe os valores padrão ou aumente o consumo de recursos para reduzir o tempo de cálculo.
1. (Opcional) Em Tipo de instância, escolha o tipo de instância de computação de ML que você deseja usar. Na maioria dos casos, ml.m4.xlarge é suficiente.
2. Para Contagem de instâncias, use o padrão, 1.
3. (Opcional) Em Volume adicional por instância (GB), escolha o tamanho do volume de armazenamento de ML que você deseja provisionar. Na maioria dos casos, você pode usar o padrão, 1. Se estiver usando um conjunto de dados grande, use um tamanho maior.
Forneça informações sobre os dados de entrada para o conjunto de dados de treinamento.
1. Em Channel name (Nome do canal), deixe o padrão (train) ou insira um nome mais significativo para o conjunto de dados de treinamento, como expanded-training-dataset.
2. Para InputMode, escolha Arquivo. Para treinamento incremental, você precisa usar o modo de entrada de arquivo.
3. Para o tipo de distribuição de dados S3, escolha FullyReplicated. Isso faz com que cada instância de computação de ML use uma replicação completa do conjunto de dados expandido ao treinar incrementalmente.
4. Se o conjunto de dados expandido estiver descompactado, defina o Compression type (Tipo de compactação) como None (Nenhum). Se o conjunto de dados expandido for compactado usando Gzip, defina-o como Gzip.
5. (Opcional) Se você estiver usando o modo de entrada de arquivo, deixe Tipo de conteúdo vazio. Para o modo de entrada de Pipe, especifique o tipo MIME apropriado. O Tipo de conteúdo é o tipo MIME (Multipurpose Internet Mail Extension) dos dados.
6. Em Record wrapper (Wrapper de registro), se o conjunto de dados for salvo no formato RecordIO, escolha RecordIO. Se o seu conjunto de dados não estiver salvo como um arquivo formatado com RecordIO, escolha None (Nenhum).
7. Para Tipo de dados S3, se o conjunto de dados for armazenado como um arquivo único, escolha S3Prefix. Se o conjunto de dados estiver armazenado como vários arquivos em uma pasta, escolha Manifesto.
8. Para Localização do S3, forneça a URL para o caminho onde você armazenou o conjunto de dados expandido.
9. Selecione Done (Concluído).
Para usar artefatos de modelo em um trabalho de treinamento, você precisa adicionar um novo canal e fornecer as informações necessárias sobre os artefatos do modelo.
1. Para Input data configuration (Configuração dos dados de entrada), escolha Add channel (Adicionar canal).
2. Para Channel name (Nome do canal), insira model para identificar esse canal como a origem dos artefatos de modelo.
3. Para InputMode, escolha Arquivo. Artefatos de modelo são armazenados como arquivos.
4. Para o tipo de distribuição de dados S3, escolha FullyReplicated. Isso indica que cada instância de computação de ML deve usar todos os artefatos de modelo para treinamento.
5. Para Compression type (Tipo de compactação), escolha None (Nenhum) porque estamos usando um modelo para o canal.
6. Deixe Content type (Tipo de conteúdo) vazio. O Tipo de conteúdo é o tipo MIME (Multipurpose Internet Mail Extension) dos dados. Para artefatos de modelo, deixamos o campo vazio.
7. Defina Wrapper de registro como Nenhum, pois os artefatos de modelo não são armazenados no formato RecordIO.
8. Para Tipo de dados do S3, se você estiver usando um algoritmo interno ou um algoritmo que armazena o modelo como um único arquivo, escolha S3Prefix. Se você estiver usando um algoritmo que armazena o modelo como vários arquivos, escolha Manifesto.
9. Para Localização do S3, forneça a URL para o caminho onde você armazenou os artefatos de modelo. Normalmente, o modelo é armazenado com o nome model.tar.gz. Para localizar a URL dos artefatos de modelo, no painel de navegação, escolha Inferência e depois Modelos. Na lista de modelos, escolha um modelo para exibir sua página de detalhes. A URL dos artefatos do modelo está listada em Contêiner primário.
10. Escolha Concluído.
Para Configuração dos dados de saída, forneça as seguintes informações:
1. Para Localização do S3, digite o caminho para o bucket do S3 no qual você deseja armazenar os dados de saída.
2. (Opcional) Para Chave de criptografia, você pode adicionar sua chave de criptografia AWS Key Management Service (AWS KMS) para criptografar os dados de saída em repouso. Forneça o ID da chave ou seu Número de recurso da Amazon (ARN). Para obter mais informações, consulte Chaves de criptografia gerenciadas por KMS.
(Opcional) Para Tags, adicione uma ou mais tags ao trabalho de treinamento. Uma tag é um metadado que você pode definir e atribuir a recursos AWS . Nesse caso, você pode usar tags para ajudá-lo a gerenciar seus trabalhos de treinamento. Uma tag consiste em uma chave e um valor que você define. Por exemplo, talvez você queira criar uma tag com Project como uma chave e um valor que faça referência a um projeto relacionado ao trabalho de treinamento, como Home value forecasts.
Escolha Criar trabalho de treinamento. SageMaker cria e executa trabalhos de treinamento.

Depois que o trabalho de treinamento for concluído, os artefatos do modelo recém-formados serão armazenados no S3 output path (Caminho de saída do S3) que você forneceu no campo Output data configuration (Configuração dos dados de saída). Para implantar o modelo e obter previsões, consulte Implante o modelo na Amazon EC2.

Realizar o treinamento incremental (API)

Este exemplo mostra como usar SageMaker APIs para treinar um modelo usando o algoritmo de classificação de SageMaker imagens e o conjunto de dados de imagem Caltech 256 e, em seguida, treinar um novo modelo usando o primeiro. Ele usa o Amazon S3 para fontes de entrada e saída. Consulte o bloco de anotações de amostra de treinamento incremental para obter mais detalhes sobre o uso do treinamento incremental.

nota

Neste exemplo, usamos os conjuntos de dados originais no treinamento incremental. No entanto, é possível usar conjuntos de dados diferentes, como aqueles que contêm amostras recém-adicionadas. Faça upload dos novos conjuntos de dados no S3 e faça ajustes na variável data_channelsusada para treinar o novo modelo.

Obtenha uma função AWS Identity and Access Management (IAM) que conceda as permissões necessárias e inicialize as variáveis de ambiente:


import sagemaker
from sagemaker import get_execution_role

role = get_execution_role()
print(role)

sess = sagemaker.Session()

bucket=sess.default_bucket()
print(bucket)
prefix = 'ic-incr-training'

Obtenha a imagem de treinamento para o algoritmo de classificação de imagem:


from sagemaker.amazon.amazon_estimator import get_image_uri

training_image = get_image_uri(sess.boto_region_name, 'image-classification', repo_version="latest")
#Display the training image
print (training_image)

Faça download dos conjuntos de dados de treinamento e validação e, em seguida, faça upload desses dados no Amazon Simple Storage Service (Amazon S3):


import os
import urllib.request
import boto3

# Define a download function
def download(url):
    filename = url.split("/")[-1]
    if not os.path.exists(filename):
        urllib.request.urlretrieve(url, filename)

# Download the caltech-256 training and validation datasets
download('http://data.mxnet.io/data/caltech-256/caltech-256-60-train.rec')
download('http://data.mxnet.io/data/caltech-256/caltech-256-60-val.rec')

# Create four channels: train, validation, train_lst, and validation_lst
s3train = 's3://{}/{}/train/'.format(bucket, prefix)
s3validation = 's3://{}/{}/validation/'.format(bucket, prefix)

# Upload the first files to the train and validation channels
!aws s3 cp caltech-256-60-train.rec $s3train --quiet
!aws s3 cp caltech-256-60-val.rec $s3validation --quiet

Defina os hiperparâmetros de treinamento:


# Define hyperparameters for the estimator
hyperparams = { "num_layers": "18",
                "resize": "32",
                "num_training_samples": "50000",
                "num_classes": "10",
                "image_shape": "3,28,28",
                "mini_batch_size": "128",
                "epochs": "3",
                "learning_rate": "0.1",
                "lr_scheduler_step": "2,3",
                "lr_scheduler_factor": "0.1",
                "augmentation_type": "crop_color",
                "optimizer": "sgd",
                "momentum": "0.9",
                "weight_decay": "0.0001",
                "beta_1": "0.9",
                "beta_2": "0.999",
                "gamma": "0.9",
                "eps": "1e-8",
                "top_k": "5",
                "checkpoint_frequency": "1",
                "use_pretrained_model": "0",
                "model_prefix": "" }

Crie um objeto estimador e treine o primeiro modelo usando os conjuntos de dados de treinamento e validação:


# Fit the base estimator
s3_output_location = 's3://{}/{}/output'.format(bucket, prefix)
ic = sagemaker.estimator.Estimator(training_image,
                                   role,
                                   instance_count=1,
                                   instance_type='ml.p2.xlarge',
                                   volume_size=50,
                                   max_run=360000,
                                   input_mode='File',
                                   output_path=s3_output_location,
                                   sagemaker_session=sess,
                                   hyperparameters=hyperparams)

train_data = sagemaker.inputs.TrainingInput(s3train, distribution='FullyReplicated',
                                        content_type='application/x-recordio', s3_data_type='S3Prefix')
validation_data = sagemaker.inputs.TrainingInput(s3validation, distribution='FullyReplicated',
                                             content_type='application/x-recordio', s3_data_type='S3Prefix')

data_channels = {'train': train_data, 'validation': validation_data}

ic.fit(inputs=data_channels, logs=True)

Para usar o modelo para treinar outro modelo de forma incremental, crie um novo objeto estimador e use os artefatos do modelo (ic.model_data, neste exemplo) para o argumento de entrada model_uri:


# Given the base estimator, create a new one for incremental training
incr_ic = sagemaker.estimator.Estimator(training_image,
                                        role,
                                        instance_count=1,
                                        instance_type='ml.p2.xlarge',
                                        volume_size=50,
                                        max_run=360000,
                                        input_mode='File',
                                        output_path=s3_output_location,
                                        sagemaker_session=sess,
                                        hyperparameters=hyperparams,
                                        model_uri=ic.model_data) # This parameter will ingest the previous job's model as a new channel
incr_ic.fit(inputs=data_channels, logs=True)

Após o término do trabalho de treinamento, os artefatos de modelo recém-treinados são armazenados no S3 output path que você forneceu em Output_path. Para implantar o modelo e obter previsões, consulte Implante o modelo na Amazon EC2.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Modifique seu script de treinamento para atribuir grupos de instâncias

Treinamento de spot gerenciado