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à.

# Eseguire il training di un modello
<a name="ex1-train-model"></a>

In questa fase, scegli un algoritmo di addestramento ed esegui un job di addestramento per il modello. L'[SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) fornisce stimatori di framework e stimatori generici per addestrare il modello mentre orchestrate il ciclo di vita dell'apprendimento automatico (ML), accedendo alle funzionalità di SageMaker intelligenza artificiale per la formazione e alle infrastrutture AWS , come Amazon Elastic Container Registry (Amazon ECR), Amazon Elastic Compute Cloud (Amazon EC2), Amazon Simple Storage Service (Amazon) 3) Simple Storage Service S3. Per ulteriori informazioni sugli stimatori di framework integrati nell' SageMaker intelligenza artificiale, consulta [Frameworks](https://sagemaker.readthedocs.io/en/stable/frameworks/index.html) nella documentazione di Amazon [Python SageMaker SDK](https://sagemaker.readthedocs.io/en/stable). Per ulteriori informazioni sugli algoritmi integrati, consulta [Algoritmi integrati e modelli preaddestrati in Amazon SageMaker](algos.md).

**Topics**
+ [Scegliere l'algoritmo di addestramento](#ex1-train-model-select-algorithm)
+ [Creazione ed esecuzione di un processo di addestramento](#ex1-train-model-sdk)

## Scegliere l'algoritmo di addestramento
<a name="ex1-train-model-select-algorithm"></a>

Per scegliere l'algoritmo giusto per il tuo set di dati, in genere devi valutare diversi modelli per trovare i modelli più adatti ai tuoi dati. Per semplicità, l'algoritmo [XGBoost algoritmo con Amazon SageMaker AI](xgboost.md) integrato di SageMaker intelligenza artificiale viene utilizzato in questo tutorial senza la valutazione preliminare dei modelli.

**Suggerimento**  
Se desideri che l' SageMaker intelligenza artificiale trovi un modello appropriato per il tuo set di dati tabulari, usa Amazon SageMaker Autopilot che automatizza una soluzione di machine learning. Per ulteriori informazioni, consulta [SageMaker Pilota automatico](autopilot-automate-model-development.md).

## Creazione ed esecuzione di un processo di addestramento
<a name="ex1-train-model-sdk"></a>

Dopo aver capito quale modello usare, inizia a costruire uno stimatore di intelligenza artificiale per la formazione. SageMaker Questo tutorial utilizza l'algoritmo XGBoost integrato per lo stimatore generico SageMaker AI.

**Per eseguire il processo di addestramento di un modello**

1. Importa l'[SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) e inizia recuperando le informazioni di base dalla tua sessione di intelligenza artificiale corrente. SageMaker 

   ```
   import sagemaker
   
   region = sagemaker.Session().boto_region_name
   print("AWS Region: {}".format(region))
   
   role = sagemaker.get_execution_role()
   print("RoleArn: {}".format(role))
   ```

   Questa procedura restituisce le seguenti informazioni:
   + `region`— La AWS regione corrente in cui è in esecuzione l'istanza SageMaker AI Notebook.
   + `role`: il ruolo IAM utilizzato dall'istanza del notebook.
**Nota**  
Controlla la versione di SageMaker Python SDK eseguendo. `sagemaker.__version__` Questo tutorial è basato su `sagemaker>=2.20`. Se l'SDK non è aggiornato, installa la versione più recente eseguendo il seguente comando:   

   ```
   ! pip install -qU sagemaker
   ```
Se esegui questa installazione nelle istanze di SageMaker Studio o notebook esistenti, devi aggiornare manualmente il kernel per completare l'applicazione dell'aggiornamento della versione.

1. Crea uno XGBoost stimatore usando la classe. `sagemaker.estimator.Estimator` Nel codice di esempio seguente, lo XGBoost stimatore è denominato. `xgb_model`

   ```
   from sagemaker.debugger import Rule, ProfilerRule, rule_configs
   from sagemaker.session import TrainingInput
   
   s3_output_location='s3://{}/{}/{}'.format(bucket, prefix, 'xgboost_model')
   
   container=sagemaker.image_uris.retrieve("xgboost", region, "1.2-1")
   print(container)
   
   xgb_model=sagemaker.estimator.Estimator(
       image_uri=container,
       role=role,
       instance_count=1,
       instance_type='ml.m4.xlarge',
       volume_size=5,
       output_path=s3_output_location,
       sagemaker_session=sagemaker.Session(),
       rules=[
           Rule.sagemaker(rule_configs.create_xgboost_report()),
           ProfilerRule.sagemaker(rule_configs.ProfilerReport())
       ]
   )
   ```

   Per costruire lo stimatore SageMaker AI, specifica i seguenti parametri:
   + `image_uri`: specifica l'URI dell'immagine del container di addestramento. In questo esempio, l'URI del contenitore di XGBoost addestramento SageMaker AI viene specificato utilizzando. `sagemaker.image_uris.retrieve`
   + `role`— Il ruolo AWS Identity and Access Management (IAM) utilizzato dall' SageMaker IA per eseguire attività per tuo conto (ad esempio, leggere i risultati della formazione, chiamare gli artefatti del modello di chiamata da Amazon S3 e scrivere i risultati della formazione su Amazon S3). 
   + `instance_count` e `instance_type`: il tipo e il numero di istanze di calcolo ML Amazon EC2 da utilizzare per l'addestramento del modello. Per questo esercizio di addestramento, utilizza una singola istanza `ml.m4.xlarge` con 4 CPU, 16 GB di memoria, uno storage Amazon Elastic Block Store (Amazon EBS) e prestazioni di rete elevate. Per ulteriori informazioni sui tipi di istanze di calcolo EC2, consulta [Amazon EC2 Instance Types](https://aws.amazon.com/ec2/instance-types/). Per ulteriori informazioni sulla fatturazione, consulta i [ SageMaker prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/). 
   + `volume_size`: la dimensione, in GB, del volume di storage EBS da collegare all'istanza di addestramento. Deve avere spazio sufficiente per archiviare i dati di addestramento se utilizzi la modalità `File` (la modalità `File` è attivata per impostazione predefinita). Se non specifichi questo parametro, il suo valore predefinito è 30.
   + `output_path`— Il percorso verso il bucket S3 in cui l' SageMaker intelligenza artificiale archivia l'artefatto del modello e i risultati dell'allenamento.
   + `sagemaker_session`— L'oggetto di sessione che gestisce le interazioni con le operazioni SageMaker API e altri AWS servizi utilizzati dal processo di formazione.
   + `rules`— Specificare un elenco di regole integrate nel SageMaker Debugger. In questo esempio, la `create_xgboost_report()` regola crea un XGBoost report che fornisce informazioni dettagliate sui progressi e sui risultati della formazione e la `ProfilerReport()` regola crea un report sull'utilizzo delle risorse di calcolo EC2. Per ulteriori informazioni, consulta [SageMaker Report interattivo del debugger per XGBoost](debugger-report-xgboost.md).
**Suggerimento**  
Se desideri eseguire l'addestramento distribuito di modelli di deep learning di grandi dimensioni, come reti neurali convoluzionali (CNN) e modelli di elaborazione del linguaggio naturale (NLP), utilizza SageMaker AI Distributed per il parallelismo dei dati o il parallelismo dei modelli. Per ulteriori informazioni, consulta [Formazione distribuita in Amazon SageMaker AI](distributed-training.md).

1. Imposta gli iperparametri per l'algoritmo chiamando il metodo dello stimatore. XGBoost `set_hyperparameters` Per un elenco completo degli XGBoost iperparametri, vedere. [XGBoost iperparametri](xgboost_hyperparameters.md)

   ```
   xgb_model.set_hyperparameters(
       max_depth = 5,
       eta = 0.2,
       gamma = 4,
       min_child_weight = 6,
       subsample = 0.7,
       objective = "binary:logistic",
       num_round = 1000
   )
   ```
**Suggerimento**  
Puoi anche ottimizzare gli iperparametri utilizzando la funzione di ottimizzazione degli iperparametri SageMaker AI. Per ulteriori informazioni, consulta [Ottimizzazione automatica dei modelli con AI SageMaker](automatic-model-tuning.md). 

1. Utilizza la classe `TrainingInput` per configurare un flusso di input di dati per l'addestramento. Il seguente codice di esempio mostra come configurare gli oggetti `TrainingInput` per utilizzare i set di dati di addestramento e di convalida che hai caricato su Amazon S3 nella sezione [Suddivisione del set di dati in set di dati di addestramento, di convalida e di test](ex1-preprocess-data.md#ex1-preprocess-data-transform).

   ```
   from sagemaker.session import TrainingInput
   
   train_input = TrainingInput(
       "s3://{}/{}/{}".format(bucket, prefix, "data/train.csv"), content_type="csv"
   )
   validation_input = TrainingInput(
       "s3://{}/{}/{}".format(bucket, prefix, "data/validation.csv"), content_type="csv"
   )
   ```

1. Per iniziare l'addestramento del modello, chiama il metodo `fit` dello strumento di valutazione con i set di dati di addestramento e di convalida. Impostando `wait=True`, il metodo `fit` visualizza i log di avanzamento e attende il completamento dell'addestramento.

   ```
   xgb_model.fit({"train": train_input, "validation": validation_input}, wait=True)
   ```

   Per ulteriori informazioni sull’addestramento del modello, consulta [Addestra un modello con Amazon SageMaker](how-it-works-training.md). Questo processo di addestramento del tutorial potrebbe richiedere fino a 10 minuti.

   Al termine del processo di formazione, puoi scaricare un rapporto di XGBoost formazione e un rapporto di profilazione generati da Debugger. SageMaker Il rapporto sull' XGBoost allenamento offre informazioni dettagliate sui progressi e sui risultati dell'allenamento, ad esempio la funzione di perdita rispetto all'iterazione, l'importanza delle funzionalità, la matrice di confusione, le curve di precisione e altri risultati statistici dell'allenamento. Ad esempio, è possibile trovare la seguente curva di perdita nel rapporto sull' XGBoost allenamento, che indica chiaramente l'esistenza di un problema di sovradattamento.  
![\[Il grafico nel rapporto di XGBoost allenamento.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/get-started-ni/gs-ni-train-loss-curve-validation-overfitting.png)

   Esegui il seguente codice per specificare l'URI del bucket S3 in cui vengono generati i report di addestramento di Debugger e controlla se i report esistono.

   ```
   rule_output_path = xgb_model.output_path + "/" + xgb_model.latest_training_job.job_name + "/rule-output"
   ! aws s3 ls {rule_output_path} --recursive
   ```

   Scarica i report di XGBoost formazione e profilazione di Debugger nell'area di lavoro corrente:

   ```
   ! aws s3 cp {rule_output_path} ./ --recursive
   ```

   Eseguite lo IPython script seguente per ottenere il collegamento al file del rapporto di formazione: XGBoost 

   ```
   from IPython.display import FileLink, FileLinks
   display("Click link below to view the XGBoost Training report", FileLink("CreateXgboostReport/xgboost_report.html"))
   ```

   Il seguente script IPython restituisce il collegamento al file del report di profiling di Debugger che mostra riepiloghi e dettagli relativi a utilizzo delle risorse dell'istanza EC2, risultati del rilevamento dei colli di bottiglia del sistema e risultati di profiling delle operazioni Python:

   ```
   profiler_report_name = [rule["RuleConfigurationName"] 
                           for rule in xgb_model.latest_training_job.rule_job_summary() 
                           if "Profiler" in rule["RuleConfigurationName"]][0]
   profiler_report_name
   display("Click link below to view the profiler report", FileLink(profiler_report_name+"/profiler-output/profiler-report.html"))
   ```
**Suggerimento**  
Se i report HTML non visualizzano grafici nella JupyterLab vista, è necessario scegliere **Trust HTML** nella parte superiore dei report.  
Per identificare problemi di formazione, come l'overfit, la scomparsa dei gradienti e altri problemi che impediscono la convergenza del modello, usa SageMaker Debugger e intraprendi azioni automatiche durante la prototipazione e l'addestramento dei modelli ML. Per ulteriori informazioni, consulta [Amazon SageMaker Debugger](train-debugger.md). Per trovare un'analisi completa dei parametri del modello, consulta il notebook di esempio [Explainability with Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/xgboost_census_explanations/xgboost-census-debugger-rules.html#Explainability-with-Amazon-SageMaker-Debugger). 

Ora disponi di un modello addestrato. XGBoost SageMaker L'intelligenza artificiale memorizza l'artefatto del modello nel tuo bucket S3. Per trovare la posizione dell'artefatto del modello, esegui il seguente codice per stampare l'attributo model\$1data dello strumento di valutazione `xgb_model`:

```
xgb_model.model_data
```

**Suggerimento**  
Per misurare le distorsioni che possono verificarsi durante ogni fase del ciclo di vita del machine learning (raccolta dei dati, addestramento e ottimizzazione dei modelli e monitoraggio dei modelli ML utilizzati per la previsione), usa Clarify. SageMaker Per ulteriori informazioni, consulta [Spiegabilità del modello](clarify-model-explainability.md). Per un end-to-end esempio, consultate il taccuino di esempio [Fairness](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-clarify/fairness_and_explainability/fairness_and_explainability.html) and Explainability with Clarify. SageMaker