

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Usa la formazione incrementale in Amazon SageMaker AI
<a name="incremental-training"></a>

Nel tempo, potresti notare che un modello genera inferenze di qualità inferiore rispetto al passato. Con l’addestramento incrementale, puoi utilizzare gli artefatti di un modello esistente e un set di dati espanso per eseguire l’addestramento di un nuovo modello. L’addestramento incrementale consente di risparmiare tempo e risorse.

Utilizza l’addestramento incrementale per:
+ Eseguire l’addestramento di un nuovo modello con un set di dati espanso che contiene un modello sottostante che non è stato preso in considerazione nell’addestramento precedente e che ha prodotto prestazioni del modello scadenti.
+ Utilizzare tutti o una parte degli artefatti di un modello disponibile pubblicamente in un processo di addestramento. Non è necessario eseguire l’addestramento di un nuovo modello da zero.
+ Riprendere un processo di addestramento interrotto.
+ Eseguire l’addestramento di più varianti di un modello, con diverse impostazioni degli iperparametri o con set di dati diversi.

Per ulteriori informazioni sui processi di addestramento, consulta [Addestra un modello con Amazon SageMaker](how-it-works-training.md).

Puoi allenarti in modo incrementale utilizzando la console SageMaker AI o l'SDK [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).

**Importante**  
Al momento, l’addestramento incrementale è supportato solo da tre algoritmi integrati: [Rilevamento di oggetti - MXNet](object-detection.md), [Classificazione delle immagini - MXNet](image-classification.md) e [Algoritmo di segmentazione semantica](semantic-segmentation.md).

**Topics**
+ [Esecuzione dell’addestramento incrementale (console)](#incremental-training-console)
+ [Esecuzione dell’addestramento incrementale (API)](#incremental-training-api)

## Esecuzione dell’addestramento incrementale (console)
<a name="incremental-training-console"></a>

Per completare questa procedura, avrai bisogno di:
+ L’URI del bucket Amazon Simple Storage Service (Amazon S3) in cui sono stati memorizzati i dati di addestramento.
+ L'URI del bucket S3 dove desideri archiviare l'output del processo. 
+ Il percorso di Amazon Elastic Container Registry in cui è memorizzato il codice di addestramento. Per ulteriori informazioni, consulta [Docker Registry Paths and Example Code](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths).
+ L'URL del bucket S3 in cui hai archiviato gli artefatti del modello da utilizzare nell’addestramento incrementale. Per trovare l'URL per gli artefatti del modello, consulta la pagina dei dettagli del processo di addestramento utilizzato per creare il modello. Per trovare la pagina dei dettagli, nella console SageMaker AI, scegli **Inferenza**, scegli **Modelli**, quindi scegli il modello.

Per riavviare un processo di addestramento interrotto, utilizza l'URL per gli artefatti del modello archiviati nella pagina dei dettagli, con la stessa procedura che utilizzi per un modello o un processo di addestramento completato.

**Per eseguire l’addestramento incrementale (console)**

1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).

1. Nel riquadro di navigazione, scegliere **Addestramento**, quindi **Processi di addestramento**. 

1. Scegliere **Crea processo di addestramento**.

1. Fornire un nome per il processo di addestramento. Il nome deve essere univoco all'interno di una AWS regione di un AWS account. Il nome del processo di addestramento deve essere composto da 1 a 63 caratteri. I caratteri validi sono a-z, A-Z, 0-9 e . : \$1 = @ \$1 % - (trattino).

1. Scegliere l'algoritmo da utilizzare. Per informazioni sugli algoritmi, consulta [Algoritmi integrati e modelli preaddestrati in Amazon SageMaker](algos.md). 

1. (Facoltativo) Per **Configurazione delle risorse**, lasciare i valori predefiniti o aumentare l'utilizzo delle risorse, in modo da ridurre il tempo di elaborazione.

   1. (Facoltativo) Per **Tipo di istanza**, scegliere il tipo di istanza di calcolo ML da utilizzare. Nella maggior parte dei casi, **ml.m4.xlarge** è sufficiente. 

   1. Per **Conteggio istanze**, utilizzare l'impostazione predefinita 1.

   1. (Facoltativo) Per **Volume aggiuntivo per istanza in GB**, scegliere le dimensioni del volume di storage ML da assegnare. Nella maggior parte dei casi, è possibile utilizzare l'impostazione predefinita 1. Se si utilizza un set di dati più grande, scegliere una dimensione maggiore.

1. Fornire informazioni sui dati di input per il set di dati di addestramento.

   1. Per **Nome canale**, lasciare l'impostazione predefinita (**train**) oppure inserire un nome più significativo per il set di dati di addestramento, ad esempio **expanded-training-dataset**.

   1. Per **InputMode**, scegli **File**. Per l’addestramento incrementale, è necessario utilizzare la modalità di input File.

   1. Per il **tipo di distribuzione dei dati S3**, scegli **FullyReplicated**. In questo modo, ogni istanza di calcolo ML utilizza una replica completa del set di dati espanso quando esegue l’addestramento incrementale.

   1. Se il set di dati espanso non è compresso, impostare **Tipo di compressione** su **Nessuno**. Se il set di dati espanso è compresso con Gzip, impostarlo su **Gzip**.

   1. (Facoltativo) Se si utilizza la modalità di input File, lasciare vuoto **Tipo di contenuto**. Per la modalità di input Pipe, specificare il tipo MIME appropriato. Il *tipo di contenuto* corrisponde al tipo di dati Multipurpose Internet Mail Extensions (MIME).

   1. Per **Wrapper dei record**, se il set di dati viene salvato in formato RecordIO, scegliere **RecordIO**. Se il set di dati non viene salvato come file in formato RecordIO, scegliere **Nessuno**.

   1. Per **Tipo di dati S3**, se il set di dati viene archiviato come singolo file, scegliere **S3Prefix**. Se il set di dati viene archiviato come diversi file in una cartella, scegliere **Manifest**.

   1. Per **Percorso S3**, fornire l'URL per il percorso in cui è stato archiviato il set di dati espanso.

   1. Seleziona **Fatto**.

1. Per utilizzare gli artefatti del modello in un processo di addestramento, è necessario aggiungere un nuovo canale e fornire le informazioni necessarie sugli artefatti del modello.

   1. Per **Configurazione dei dati di input**, scegliere **Aggiungi canale**.

   1. Per **Nome canale**, immettere **model** per identificare il canale come origine degli artefatti del modello.

   1. Per **InputMode**, scegli **File**. Gli artefatti del modello vengono archiviati come file.

   1. Per il **tipo di distribuzione dei dati S3**, scegli **FullyReplicated**. Questo indica che ogni istanza di calcolo ML deve utilizzare tutti gli artefatti del modello per l’addestramento. 

   1. Per **Tipo di compressione**, scegliere **Nessuno** perché si sta utilizzando un modello per il canale.

   1. Lasciare vuoto **Tipo di contenuto**. Il tipo di contenuto corrisponde al tipo di dati Multipurpose Internet Mail Extensions (MIME). Per gli artefatti del modello, viene lasciato vuoto.

   1. Impostare **Wrapper dei record** su **Nessuno** perché gli artefatti del modello non vengono archiviati in formato RecordIO.

   1. Per **Tipo di dati S3**, se si utilizza un algoritmo predefinito o un algoritmo che archivia il modello come singolo file, scegliere **S3Prefix**. Se si utilizza un algoritmo che archivia il modello come diversi file, scegliere **Manifest**.

   1. Per **Percorso S3**, fornire l'URL per il percorso in cui sono stati archiviati gli artefatti del modello. Di solito, il modello viene archiviato con il nome `model.tar.gz`. Per trovare l'URL per gli artefatti del modello, nel riquadro di navigazione scegliere **Inferenza**, quindi **Modelli**. Scegliere un modello dall'elenco per visualizzare la pagina dei dettagli. L'URL per gli artefatti del modello è elencato in **Container primario**.

   1. Seleziona **Fatto**.

1. Per **Configurazione dei dati di output**, specificare le seguenti informazioni:

   1. Per **Percorso S3**, digitare il percorso del bucket S3 in cui archiviare i dati di output.

   1. (Facoltativo) Per **Chiave di crittografia**, si può aggiungere la chiave di crittografia AWS Key Management Service (AWS KMS) per crittografare i dati di output inattivi. Fornire l'ID della chiave o il relativo ARN (Amazon Resource Number). Per ulteriori informazioni, consulta [KMS-Managed Encryption Keys](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingKMSEncryption.html).

1. (Facoltativo) Per **Tag**, aggiungere uno o più tag per gestire il processo di addestramento. Un *tag* è costituito da metadati che è possibile definire e assegnare alle risorse AWS . In questo caso, è possibile utilizzare i tag per semplificare la gestione dei processi di addestramento. Un tag è composto da una chiave e da un valore definiti dall'utente. Ad esempio, è possibile creare un tag con la chiave **Project** e un valore che fa riferimento a un progetto correlato al processo di addestramento, ad esempio **Home value forecasts**.

1. Scegli **Crea un lavoro di formazione.** SageMaker L'intelligenza artificiale crea e gestisce lavori di formazione.

Dopo il completamento del processo di addestramento, gli artefatti del modello appena addestrati vengono archiviati in **Percorso di output S3** specificato nel campo **Configurazione dei dati di output**. Per distribuire il modello per ottenere le previsioni, consulta [Implementazione del modello in Amazon EC2](ex1-model-deployment.md).

## Esecuzione dell’addestramento incrementale (API)
<a name="incremental-training-api"></a>

Questo esempio mostra come utilizzare l' SageMaker intelligenza artificiale APIs per addestrare un modello utilizzando l'algoritmo di classificazione delle immagini SageMaker AI e il [Caltech 256 Image Dataset](https://data.caltech.edu/records/nyy15-4j048), quindi addestrare un nuovo modello utilizzando il primo. Utilizza Amazon S3 per le origini di input e output. Consulta il [notebook di esempio per l’addestramento incrementale](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/imageclassification_caltech/Image-classification-incremental-training-highlevel.html) per ulteriori dettagli sull'utilizzo dell’addestramento incrementale.

**Nota**  
In questo esempio, abbiamo utilizzato i set di dati originali nell’addestramento incrementale, ma puoi utilizzare set di dati diversi, ad esempio quelli che contengono esempi appena aggiunti. Carica il nuovo set di dati in S3 e regola la variabile `data_channels` utilizzata per l’addestramento del nuovo modello.

Ottieni un ruolo AWS Identity and Access Management (IAM) che conceda le autorizzazioni necessarie e inizializzi le variabili di 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'
```

Scarica l'immagine di addestramento per l'algoritmo di classificazione delle immagini:

```
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)
```

Scarica i set di dati di addestramento e convalida, quindi caricali su 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
```

Definisci gli iperparametri di addestramento:

```
# 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": "" }
```

Crea un oggetto dello strumento di valutazione e addestra il primo modello utilizzando i set di dati di addestramento e convalida:

```
# 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)
```

Per utilizzare il modello in modo che esegua l’addestramento incrementale di un altro modello, crea un nuovo oggetto dello strumento di valutazione e utilizza gli artefatti del modello (`ic.model_data`, in questo esempio) per l'argomento di input `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)
```

Dopo il completamento del processo di addestramento, gli artefatti del modello appena addestrati vengono archiviati in `S3 output path`, specificato in `Output_path`. Per distribuire il modello per ottenere le previsioni, consulta [Implementazione del modello in Amazon EC2](ex1-model-deployment.md).