Addestrare un modello di ML con scikit-learn e XGBoost

Configura il bucket Cloud Storage

Ti servirà un bucket Cloud Storage per archiviare il codice di addestramento e le dipendenze. Ai fini di questo tutorial, è più semplice utilizzare un bucket Cloud Storage dedicato nello stesso progetto che utilizzi per AI Platform Training.

Se utilizzi un bucket in un progetto diverso, devi assicurarti che l'account di servizio AI Platform Training possa accedere al codice di addestramento e alle dipendenze in Cloud Storage. Senza le autorizzazioni appropriate, il job di addestramento non va a buon fine. Scopri come concedere le autorizzazioni per lo spazio di archiviazione.

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

Questa sezione spiega come creare un nuovo bucket. Puoi utilizzare un bucket esistente, ma deve trovarsi nella stessa regione in cui prevedi di eseguire i job di AI Platform. 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.

1. Specifica un nome per il nuovo bucket. Il nome deve essere univoco in tutti i bucket di Cloud Storage.

   BUCKET_NAME="YOUR_BUCKET_NAME"

   Ad esempio, utilizza il nome del progetto con -aiplatform aggiunto:

   PROJECT_ID=$(gcloud config list project --format "value(core.project)")
   BUCKET_NAME=${PROJECT_ID}-aiplatform

2. Controlla il nome del bucket che hai creato.

   echo $BUCKET_NAME

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

4. Crea il nuovo bucket:

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

Creare 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
• Caricare i 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:

• Codice di addestramento completo per scikit-learn
• Codice di addestramento completo per XGBoost

Configurazione

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

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>'

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 normale processo di sviluppo, carichi i tuoi dati su 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 da gsutil a stdout:

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)

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.

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

# 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, il modulo di addestramento addestra un modello sui dati di addestramento dell'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. Scopri di più sui requisiti di denominazione per il file del modello.

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

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

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

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

Requisiti per la 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).

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.

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

# 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 pacchetto di applicazioni di addestramento che includa 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:

iris_sklearn_trainer/
    __init__.py
    iris_training.py

iris_xgboost_trainer/
    __init__.py
    iris_training.py

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

Esegui il trainer localmente

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

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

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

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

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

Invia il job di addestramento

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

Specificare i parametri del job di addestramento

Imposta le seguenti variabili di ambiente per ogni parametro nella richiesta del job di addestramento:

• BUCKET_NAME: il nome del bucket Cloud Storage.
• JOB_NAME: un nome da utilizzare per il job (solo lettere maiuscole e minuscole, numeri e trattini bassi, che deve iniziare 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 alla directory principale dell'applicazione di addestramento. 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 trovi nella stessa regione.
• RUNTIME_VERSION: devi specificare una versione di runtime di AI Platform Training che supporti scikit-learn. In questo esempio, 2.11.
• PYTHON_VERSION: la versione di Python da utilizzare per il job. Per questo tutorial, specifica 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 utilizzare livelli di scalabilità personalizzati per definire la tua configurazione del cluster per l'addestramento.

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

    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

    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 gli stream e le istruzioni di logging stdout e stderr. Questi log vengono archiviati in Logging e sono visibili sia durante sia dopo l'esecuzione.

Per visualizzare i log del job di addestramento:

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