Questa versione precedente di AI Platform Training è ritirata e non sarà più disponibile su Google Cloud dopo il 31 gennaio 2025. Esegui la migrazione delle tue risorse all'addestramento personalizzato di Vertex AI per accedere a nuove funzionalità di machine learning non disponibili nella piattaforma AI.

Questa pagina è stata tradotta dall'API Cloud Translation.

Addestrare un modello di ML con scikit-learn e XGBoost

Il servizio AI Platform Training gestisce le risorse di calcolo nel cloud per addestrare i tuoi modelli. Questa pagina descrive la procedura per addestrare un modello con scikit-learn e XGBoost utilizzando AI Platform Training.

Panoramica

In questo tutorial, addestri un semplice modello per prevedere la specie di fiori utilizzando il set di dati Iris. Dopo aver aggiustato il codice di addestramento del modello per scaricare i dati da Cloud Storage e caricare il file del modello salvato su Cloud Storage, crea un pacchetto dell'applicazione di addestramento e utilizzalo per eseguire l'addestramento su AI Platform Training.

Come addestrare il tuo modello su AI Platform Training

Dopo aver completato la procedura di configurazione iniziale, puoi addestrare il tuo modello su AI Platform Training in tre passaggi:

Crea il modulo di addestramento Python
- Aggiungi il codice per scaricare i tuoi dati da Cloud Storage in modo che AI Platform Training può usarlo
- Aggiungi il codice per esportare e salvare il modello in Cloud Storage al termine dell'addestramento del modello con AI Platform Training
prepara un pacchetto dell'applicazione di addestramento
Invia il job di addestramento

Il processo di configurazione iniziale include la creazione di un progetto Google Cloud, l'abilitazione fatturazione e API, configurazione di un bucket Cloud Storage da utilizzare con AI Platform Training e installazione locale di scikit-learn o XGBoost. Se hai già configurato e installato tutto, passa a creazione del codice di addestramento del modello.

Prima di iniziare

Completa i seguenti passaggi per configurare un account Google Cloud, attivare l'API AI Platform Training e installare e attivare Cloud SDK.

Configura il progetto Google Cloud

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the AI Platform Training & Prediction and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the AI Platform Training & Prediction and Compute Engine APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Configura l'ambiente

Scegli una delle opzioni riportate di seguito per configurare l'ambiente localmente su macOS o in un ambiente remoto su Cloud Shell.

Per gli utenti di macOS, ti consigliamo di configurare l'ambiente utilizzando la scheda MACOS di seguito. Cloud Shell, mostrato nella scheda CLOUD SHELL, disponibile su macOS, Linux e Windows. Cloud Shell offre un modo rapido provare AI Platform Training, ma non è adatta per attività di sviluppo continue.

macOS

Controlla l'installazione di Python
Conferma di avere Python installato e, se necessario, installarlo.
```
python -V
```
Controlla l'installazione di pip
pip è il gestore di pacchetti di Python, incluso nelle versioni correnti di Python. Per verificare se pip è già installato, esegui pip --version. In caso contrario, scopri come installare pip.

Puoi eseguire l'upgrade di pip utilizzando il seguente comando:
```
pip install -U pip
```
Per ulteriori dettagli, consulta la documentazione di pip.
Installa virtualenv
virtualenv è uno strumento per creare ambienti Python isolati. Per verificare se hai già installato virtualenv, esegui virtualenv --version. In caso contrario, installa virtualenv:
```
pip install --user --upgrade virtualenv
```
Per creare un ambiente di sviluppo isolato per questa guida, crea un nuovo ambiente virtuale in virtualenv. Ad esempio, il seguente comando attiva un ambiente denominato aip-env:
```
virtualenv aip-env
source aip-env/bin/activate
```
Ai fini di questo tutorial, esegui gli altri comandi all'interno completamente gestito di Google Cloud.
Consulta ulteriori informazioni sull'utilizzo di virtualenv. Per uscire da virtualenv, esegui deactivate.

Cloud Shell

Apri la console Google Cloud.

Console Google Cloud
Fai clic sul pulsante Attiva Google Cloud Shell in alto. della finestra della console.

Una sessione di Cloud Shell si apre all'interno di un nuovo frame nella parte inferiore della console Cloud e visualizza un prompt della riga di comando. Potrebbe essere necessario attendere qualche secondo per l'inizializzazione della sessione della shell.

La sessione di Cloud Shell è pronta per essere utilizzata.
Configura lo strumento a riga di comando gcloud in modo da utilizzare il progetto selezionato.
```
gcloud config set project [selected-project-id]
```
dove [selected-project-id] è l'ID progetto. (Ometti le parentesi graffe di chiusura.)

Installa framework

macOS

Nell'ambiente virtuale, esegui questo comando per installare le versioni di scikit-learn, XGBoost e pandas utilizzate in AI Platform Training versione runtime 2,11

(aip-env)$ pip install scikit-learn==1.0.2 xgboost==1.6.2 pandas==1.3.5

Fornendo i numeri di versione nel comando precedente, ti assicuri che le dipendenze nel tuo ambiente virtuale corrispondano a quelle nella versione di runtime. In questo modo, puoi evitare comportamenti imprevisti quando il codice viene eseguito su AI Platform Training.

Per ulteriori dettagli, opzioni di installazione e informazioni sulla risoluzione dei problemi, consulta le istruzioni di installazione per ciascun framework:

Cloud Shell

Esegui il seguente comando per installare scikit-learn, XGBoost e pandas:

pip install --user scikit-learn xgboost pandas

Per ulteriori dettagli, opzioni di installazione e informazioni sulla risoluzione dei problemi, consulta le istruzioni di installazione per ogni framework:

Configura il tuo bucket Cloud Storage

Avrai bisogno di un bucket Cloud Storage in cui archiviare il codice di delle dipendenze. Ai fini di questo tutorial, è più semplice utilizzare un un bucket Cloud Storage dedicato nello stesso progetto che stai utilizzando e AI Platform Training.

Se stai utilizzando un bucket in un altro progetto, garantire che l'account di servizio AI Platform Training possa accedere il codice di addestramento e le dipendenze in Cloud Storage. Senza l'appropriata autorizzazioni, il job di addestramento non va a buon fine. Scopri come concedere autorizzazioni per l'archiviazione.

Assicurati di utilizzare o configurare un bucket nella stessa regione in cui esegui i job di addestramento. Scopri le regioni in cui è disponibile per e i servizi di AI Platform Training.

Questa sezione spiega come creare un nuovo bucket. Puoi utilizzare un modello esistente ma deve trovarsi nella stessa regione in cui prevedi di eseguire AI Platform di lavoro. Inoltre, se non fa parte del progetto che utilizzi per eseguire AI Platform Training, devi esplicitamente concedere accesso agli account di servizio AI Platform Training.

Specifica un nome per il nuovo bucket. Il nome deve essere univoco in tutti in Cloud Storage.
```
BUCKET_NAME="YOUR_BUCKET_NAME"
```
Ad esempio, utilizza il nome del progetto aggiungendo -aiplatform:
```
PROJECT_ID=$(gcloud config list project --format "value(core.project)")
BUCKET_NAME=${PROJECT_ID}-aiplatform
```
Controlla il nome del bucket che hai creato.
```
echo $BUCKET_NAME
```
Seleziona una regione per il bucket e imposta una variabile di ambiente REGION.

Utilizza la stessa regione in cui prevedi di eseguire i job di AI Platform Training. Consulta le regioni disponibili per i servizi AI Platform Training.

Ad esempio, il seguente codice crea REGION e lo imposta su us-central1:
```
REGION=us-central1
```

Crea il nuovo bucket:

gcloud storage buckets create gs://$BUCKET_NAME --location=$REGION

Crea il modulo di addestramento Python

Crea un file, iris_training.py, contenente il codice per addestrare il modello. Questa sezione fornisce una spiegazione della funzione di ogni parte del codice di addestramento:

Configurazione e importazioni
Scarica i dati da Cloud Storage
Carica dati in Pandas
Addestrare e salvare il modello
Carica il file del modello salvato su Cloud Storage

Per tua comodità, il codice completo di iris_training.py è ospitato su GitHub, quindi puoi utilizzarlo per questo tutorial:

Configurazione

Importa le seguenti librerie da Python e scikit-learn o XGBoost. Imposta una variabile per il nome del bucket Cloud Storage.

scikit-learn

import datetime
import os
import subprocess
import sys
import pandas as pd
from sklearn import svm
from sklearn.externals import joblib

# Fill in your Cloud Storage bucket name
BUCKET_NAME = '<YOUR_BUCKET_NAME>'

XGBoost

import datetime
import os
import subprocess
import sys
import pandas as pd
import xgboost as xgb

# Fill in your Cloud Storage bucket name
BUCKET_NAME = '<YOUR_BUCKET_NAME>'

Scaricare i dati da Cloud Storage

Durante il tipico processo di sviluppo, carichi i tuoi dati in Cloud Storage in modo che AI Platform Training possa accedervi. I dati per questo tutorial sono ospitati in un bucket Cloud Storage pubblico: gs://cloud-samples-data/ai-platform/iris/

Il seguente codice scarica i dati utilizzando gsutil e poi li devia dalle ore gsutil alle ore stdout:

scikit-learn

iris_data_filename = 'iris_data.csv'
iris_target_filename = 'iris_target.csv'
data_dir = 'gs://cloud-samples-data/ml-engine/iris'

# gsutil outputs everything to stderr so we need to divert it to stdout.
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_data_filename),
                       iris_data_filename], stderr=sys.stdout)
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_target_filename),
                       iris_target_filename], stderr=sys.stdout)

XGBoost

iris_data_filename = 'iris_data.csv'
iris_target_filename = 'iris_target.csv'
data_dir = 'gs://cloud-samples-data/ai-platform/iris'

# gsutil outputs everything to stderr so we need to divert it to stdout.
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_data_filename),
                       iris_data_filename], stderr=sys.stdout)
subprocess.check_call(['gsutil', 'cp', os.path.join(data_dir,
                                                    iris_target_filename),
                       iris_target_filename], stderr=sys.stdout)

Caricare i dati in Pandas

Utilizza pandas per caricare i dati negli array NumPy per l'addestramento con scikit-learn o XGBoost.

scikit-learn

# Load data into pandas, then use `.values` to get NumPy arrays
iris_data = pd.read_csv(iris_data_filename).values
iris_target = pd.read_csv(iris_target_filename).values

# Convert one-column 2D array into 1D array for use with scikit-learn
iris_target = iris_target.reshape((iris_target.size,))

XGBoost

# Load data into pandas, then use `.values` to get NumPy arrays
iris_data = pd.read_csv(iris_data_filename).values
iris_target = pd.read_csv(iris_target_filename).values

# Convert one-column 2D array into 1D array for use with XGBoost
iris_target = iris_target.reshape((iris_target.size,))

Addestra e salva un modello

Crea un modulo di addestramento da eseguire con AI Platform Training. In questo esempio, addestra un modello sulla base dei dati di addestramento di Iris (iris_data e iris_target) e salva il modello addestrato esportandolo in un file. Se vuoi utilizzare AI Platform Prediction per ottenere previsioni online dopo l'addestramento, devi assegnare un nome al file del modello in base alla libreria utilizzata per esportarlo. Consulta: scopri di più sui requisiti di denominazione per del modello.

scikit-learn

Seguendo le esempio di scikit-learn sulla persistenza del modello, puoi addestrare ed esportare un modello come mostrato di seguito:

# Train the model
classifier = svm.SVC(gamma='auto', verbose=True)
classifier.fit(iris_data, iris_target)

# Export the classifier to a file
model_filename = 'model.joblib'
joblib.dump(classifier, model_filename)

Per esportare il modello, puoi anche utilizzare la libreria pickle come segue:

import pickle
with open('model.pkl', 'wb') as model_file:
  pickle.dump(classifier, model_file)

XGBoost

Puoi esportare il modello utilizzando "save_model" dell'oggetto Booster.

# Load data into DMatrix object
dtrain = xgb.DMatrix(iris_data, label=iris_target)

# Train XGBoost model
bst = xgb.train({}, dtrain, 20)

# Export the classifier to a file
model_filename = 'model.bst'
bst.save_model(model_filename)

Per esportare il modello, puoi anche utilizzare lettura di pickle come segue:

import pickle
with open('model.pkl', 'wb') as model_file:
  pickle.dump(bst, model_file)

Requisiti di denominazione dei file del modello

Per la previsione online, il file del modello salvato che carichi su Cloud Storage deve avere uno dei seguenti nomi: model.pkl, model.joblib o model.bst, a seconda della libreria utilizzata. Questa limitazione garantisce che AI Platform Prediction utilizzi lo stesso pattern per ricostruire il modello all'importazione di quello utilizzato durante l'esportazione.

Questo requisito non si applica se crei una routine di previsione personalizzata (beta).

scikit-learn

Libreria utilizzata per esportare il modello	Nome del modello corretto
`pickle`	`model.pkl`
`sklearn.externals.joblib`	`model.joblib`

XGBoost

Libreria utilizzata per esportare il modello	Nome modello corretto
`pickle`	`model.pkl`
`joblib`	`model.joblib`
`xgboost.Booster`	`model.bst`

Per le iterazioni future del modello, organizza il bucket Cloud Storage in modo che ogni nuovo modello abbia una directory dedicata.

Carica il modello salvato su Cloud Storage

Se utilizzi un bucket Cloud Storage al di fuori del progetto Google Cloud impiegato per eseguire AI Platform Training, assicurati che AI Platform Training abbia accesso al tuo bucket.

scikit-learn

# Upload the saved model file to Cloud Storage
gcs_model_path = os.path.join('gs://', BUCKET_NAME,
    datetime.datetime.now().strftime('iris_%Y%m%d_%H%M%S'), model_filename)
subprocess.check_call(['gsutil', 'cp', model_filename, gcs_model_path],
    stderr=sys.stdout)

XGBoost

# Upload the saved model file to Cloud Storage
gcs_model_path = os.path.join('gs://', BUCKET_NAME,
    datetime.datetime.now().strftime('iris_%Y%m%d_%H%M%S'), model_filename)
subprocess.check_call(['gsutil', 'cp', model_filename, gcs_model_path],
    stderr=sys.stdout)

Crea il pacchetto dell'applicazione di addestramento

Con iris_training.py creato dagli snippet precedenti, crea un corso di formazione pacchetto dell'applicazione che include iris_training.py come modulo principale.

Il modo più semplice (e consigliato) per creare un pacchetto di applicazioni di addestramento utilizza gcloud per pacchettizzare e caricare l'applicazione quando invii il job di addestramento. Questo metodo richiede la creazione di una struttura di file molto semplice con due file:

scikit-learn

Per questo tutorial, la struttura del file del pacchetto dell'applicazione di addestramento dovrebbe essere simile alla seguente:

iris_sklearn_trainer/
    __init__.py
    iris_training.py

Nella riga di comando, crea una directory in locale:
```
mkdir iris_sklearn_trainer
```
Crea un file vuoto denominato __init__.py:
```
touch iris_sklearn_trainer/__init__.py
```
Salva il codice di addestramento come iris_training.py e salva il file. all'interno della directory iris_sklearn_trainer. In alternativa, usa cURL per scaricare e salvare il file da GitHub:
```
curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/sklearn/iris_training.py > iris_sklearn_trainer/iris_training.py
```
Visualizza il codice sorgente completo su GitHub.
Verifica che il pacchetto delle applicazioni di addestramento sia configurato correttamente:
```
ls ./iris_sklearn_trainer
  __init__.py  iris_training.py
```

XGBoost

Per questo tutorial, la struttura del file del pacchetto dell'applicazione di addestramento dovrebbe essere simile alla seguente:

iris_xgboost_trainer/
    __init__.py
    iris_training.py

Nella riga di comando, crea una directory in locale:
```
mkdir iris_xgboost_trainer
```
Crea un file vuoto denominato __init__.py:
```
touch iris_xgboost_trainer/__init__.py
```
Salva il codice di addestramento come iris_training.py e salva il file. all'interno della directory iris_xgboost_trainer. In alternativa, usa cURL per scaricare e salvare il file da GitHub:
```
curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/xgboost/iris_training.py > iris_xgboost_trainer/iris_training.py
```
Visualizza il codice sorgente completo su GitHub.
Verifica che il pacchetto dell'applicazione di addestramento sia configurato correttamente:
```
ls ./iris_xgboost_trainer
  __init__.py  iris_training.py
```

Scopri di più sulla pacchettizzazione di un'applicazione di formazione.

Esegui trainer in locale

Puoi testare l'applicazione di addestramento localmente utilizzando il comando gcloud ai-platform local train. Questo passaggio è facoltativo, ma è utile per il debug.

scikit-learn

Nella riga di comando, imposta le seguenti variabili di ambiente: sostituendo [VALUES-IN-BRACKETS] con i valori appropriati:

TRAINING_PACKAGE_PATH="./iris_sklearn_trainer/"
MAIN_TRAINER_MODULE="iris_sklearn_trainer.iris_training"

Testa il job di addestramento a livello locale:

gcloud ai-platform local train \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE

XGBoost

Nella riga di comando, imposta le seguenti variabili di ambiente, sostituendo [VALUES-IN-BRACKETS] con i valori appropriati:

TRAINING_PACKAGE_PATH="./iris_xgboost_trainer/"
MAIN_TRAINER_MODULE="iris_xgboost_trainer.iris_training"

Testa il job di addestramento a livello locale:

gcloud ai-platform local train \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE

Invio del job di addestramento

In questa sezione utilizzerai gcloud ai-platform jobs submit training per inviare il tuo job di addestramento.

Specifica i parametri del job di addestramento

Imposta le seguenti variabili di ambiente per ciascun parametro nel job di addestramento richiesta:

BUCKET_NAME: il nome del bucket Cloud Storage.
JOB_NAME - Un nome da utilizzare per il job (lettere minuscole, numeri e solo trattini bassi, che iniziano con una lettera). Ad esempio, iris_scikit_learn_$(date +"%Y%m%d_%H%M%S") o iris_xgboost_$(date +"%Y%m%d_%H%M%S").
JOB_DIR: il percorso di una posizione Cloud Storage da utilizzare per i file di output del job di addestramento. Ad esempio, gs://$BUCKET_NAME/scikit_learn_job_dir o gs://$BUCKET_NAME/xgboost_job_dir.
TRAINING_PACKAGE_PATH: il percorso locale della directory radice dell'addestramento un'applicazione. Ad esempio, ./iris_sklearn_trainer/ o ./iris_xgboost_trainer/.
MAIN_TRAINER_MODULE: specifica il file che deve essere eseguito dal servizio di addestramento AI Platform Training. Questo valore è formattato come [YOUR_FOLDER_NAME.YOUR_PYTHON_FILE_NAME]. Ad esempio, iris_sklearn_trainer.iris_training o iris_xgboost_trainer.iris_training.
REGION: il nome della regione utilizzata per eseguire il job di addestramento. Utilizza una delle regioni disponibili per il servizio di addestramento AI Platform Training. Assicurati che Il bucket Cloud Storage si trova nella stessa regione.
RUNTIME_VERSION - Devi specificare un Versione del runtime di AI Platform Training che supporta scikit-learn. In questo esempio, 2.11.
PYTHON_VERSION: la versione di Python da utilizzare per il job. Per questo tutorial, e specificare Python 3.7.
SCALE_TIER: una specifica del cluster predefinita per le macchine su cui eseguire il job di addestramento. In questo caso, BASIC. Puoi anche Usa livelli di scalabilità personalizzati per definire la configurazione del tuo cluster per l'addestramento.

Per comodità, di seguito sono riportate le variabili di ambiente per questo tutorial.

scikit-learn

Sostituisci [VALUES-IN-BRACKETS] con i valori appropriati:

    BUCKET_NAME=[YOUR-BUCKET-NAME]
    JOB_NAME="iris_scikit_learn_$(date +"%Y%m%d_%H%M%S")"
    JOB_DIR=gs://$BUCKET_NAME/scikit_learn_job_dir
    TRAINING_PACKAGE_PATH="./iris_sklearn_trainer/"
    MAIN_TRAINER_MODULE="iris_sklearn_trainer.iris_training"
    REGION=us-central1
    RUNTIME_VERSION=2.11
    PYTHON_VERSION=3.7
    SCALE_TIER=BASIC

XGBoost

Sostituisci [VALUES-IN-BRACKETS] con i valori appropriati:

    BUCKET_NAME=[YOUR-BUCKET-NAME]
    JOB_NAME="iris_xgboost_$(date +"%Y%m%d_%H%M%S")"
    JOB_DIR=gs://$BUCKET_NAME/xgboost_job_dir
    TRAINING_PACKAGE_PATH="./iris_xgboost_trainer/"
    MAIN_TRAINER_MODULE="iris_xgboost_trainer.iris_training"
    REGION=us-central1
    RUNTIME_VERSION=2.11
    PYTHON_VERSION=3.7
    SCALE_TIER=BASIC

Invia la richiesta di job di addestramento:

gcloud ai-platform jobs submit training $JOB_NAME \
  --job-dir $JOB_DIR \
  --package-path $TRAINING_PACKAGE_PATH \
  --module-name $MAIN_TRAINER_MODULE \
  --region $REGION \
  --runtime-version=$RUNTIME_VERSION \
  --python-version=$PYTHON_VERSION \
  --scale-tier $SCALE_TIER

Dovresti vedere un output simile al seguente:

Job [iris_scikit_learn_[DATE]_[TIME]] submitted successfully.
Your job is still active. You may view the status of your job with the command

  $ gcloud ai-platform jobs describe iris_scikit_learn_[DATE]_[TIME]

or continue streaming the logs with the command

  $ gcloud ai-platform jobs stream-logs iris_scikit_learn_[DATE]_[TIME]

jobId: iris_scikit_learn_[DATE]_[TIME]
state: QUEUED

(Facoltativo) Visualizzazione dei log di addestramento

AI Platform Training acquisisce tutti i flussi e i log stdout e stderr istruzioni. Questi log vengono archiviati in Logging e sono visibili sia durante sia dopo l'esecuzione.

Per visualizzare i log del job di addestramento:

Console

Apri la pagina Job di AI Platform Training.

Aprire i job nella console Google Cloud
Seleziona il nome del job di addestramento da ispezionare. Questo ti porta Pagina Dettagli job per il job di addestramento selezionato.
Nei dettagli del job, seleziona il link Visualizza log. Questo ti porta alla pagina Logging, dove puoi cercare e filtrare i log il job di addestramento selezionato.

gcloud

Puoi visualizzare i log nel tuo terminale con gcloud ai-platform jobs stream-logs

gcloud ai-platform jobs stream-logs $JOB_NAME

Verifica il file del modello in Cloud Storage

Visualizza i contenuti della cartella del modello di destinazione per verificare che il file del modello salvato sia stato caricato su Cloud Storage.

gcloud storage ls gs://$BUCKET_NAME/iris_*

Output di esempio:

gs://bucket-name/iris_20180518_123815/:
gs://bucket-name/iris_20180518_123815/model.joblib

Passaggi successivi

Ottieni previsioni online con scikit-learn su AI Platform Training.
Scopri come utilizzare i livelli di scalabilità personalizzati per definire la configurazione del tuo cluster per l'addestramento.