Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.
Guida rapida: addestra un modello di machine learning con scikit-learn e XGBoost

Addestra un modello di machine learning con scikit-learn e XGBoost

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

Panoramica

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

Addestra il modello su AI Platform Training

Dopo aver completato il processo 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 possa utilizzarli
    • Aggiungi il codice da esportare e salva il modello in Cloud Storage dopo che AI Platform Training ha completato l'addestramento del modello
  • Prepara un pacchetto di applicazioni di formazione
  • Inviare il job di addestramento

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

Prima di iniziare

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

Configura il tuo progetto GCP

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API AI Platform Training & Prediction and Compute Engine.

    Abilita le API

  5. Installa Google Cloud CLI.
  6. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:

    gcloud init
  7. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  8. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  9. Abilita le API AI Platform Training & Prediction and Compute Engine.

    Abilita le API

  10. Installa Google Cloud CLI.
  11. Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:

    gcloud init

Configura l'ambiente

Scegli una delle opzioni seguenti per configurare l'ambiente localmente su macOS o un ambiente remoto su Cloud Shell.

Per gli utenti di macOS, consigliamo di configurare l'ambiente utilizzando la scheda MACOS di seguito. Cloud Shell, visualizzato nella scheda CLOUD SHELL, è disponibile su macOS, Linux e Windows. Cloud Shell fornisce un modo rapido per provare AI Platform Training, ma non è adatto per un lavoro di sviluppo continuo.

macOS

  1. Controlla l'installazione di Python
    Verifica di avere installato Python e, se necessario, di installarlo.

    python -V
  2. Verifica l'installazione di pip
    pip è il gestore dei pacchetti di Python incluso nelle versioni attuali di Python. Verifica di avere già installato pip eseguendo pip --version. Se non è così, scopri come installare pip.

    Puoi eseguire l'upgrade di pip utilizzando il seguente comando:

    pip install -U pip

    Consulta la documentazione relativa a pip per ulteriori dettagli.

  3. Installa virtualenv
    virtualenv è uno strumento per creare ambienti Python isolati. Verifica di avere già installato virtualenv eseguendo 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
  4. Ai fini di questo tutorial, esegui il resto dei comandi nel tuo ambiente virtuale.

    Leggi ulteriori informazioni sull'utilizzo di virtualenv. Per uscire da virtualenv, esegui deactivate.

Cloud Shell

  1. Apri la console Google Cloud.

    Console Google Cloud

  2. Fai clic sul pulsante Attiva Google Cloud Shell nella parte superiore della finestra della console.

    Attiva Google Cloud Shell

    Viene aperta una sessione di Cloud Shell all'interno di un nuovo frame nella parte inferiore della console e mostra un prompt della riga di comando. L'inizializzazione della sessione shell può richiedere alcuni secondi.

    Sessione di Cloud Shell

    La tua sessione di Cloud Shell è pronta per l'uso.

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

Installazione di framework

macOS

Nel tuo ambiente virtuale, esegui il comando seguente per installare le versioni di scikit-learn, XGBoost e panda utilizzate in AI Platform Training runtime version 2.11:

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

Se fornisci i numeri di versione nel comando precedente, ti assicuri che le dipendenze nel tuo ambiente virtuale corrispondano alle dipendenze nella versione di runtime. Ciò consente di evitare comportamenti imprevisti quando il codice viene eseguito su AI Platform Training.

Per saperne di più, sulle opzioni di installazione e sulle informazioni per la risoluzione dei problemi, consulta le istruzioni di installazione per ciascun framework:

Cloud Shell

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

pip install --user scikit-learn xgboost pandas

Per saperne di più, sulle opzioni di installazione e sulle informazioni per la risoluzione dei problemi, consulta le istruzioni di installazione per ciascun framework:

Configura il tuo bucket Cloud Storage

Hai bisogno di 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 il tuo 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 riesce. Scopri come concedere autorizzazioni per l'archiviazione.

Assicurati di utilizzare o configurare un bucket nella stessa regione che utilizzi per eseguire i job di addestramento. Vedi le regioni disponibili per i servizi di AI Platform Training.

Questa sezione mostra come creare un nuovo bucket. Puoi utilizzare un bucket esistente, ma deve essere nella stessa regione in cui prevedi di eseguire i job AI Platform. Inoltre, se non fa parte del progetto che stai utilizzando per eseguire AI Platform Training, devi concedere esplicitamente l'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 in 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 intendi eseguire job di AI Platform Training. Vedi le regioni disponibili per i servizi di AI Platform Training.

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

    REGION=us-central1
  4. Crea il nuovo bucket:

    gsutil mb -l $REGION gs://$BUCKET_NAME

Crea il modulo di addestramento Python

Crea un file iris_training.py contenente il codice per addestrare il modello. Questa sezione spiega cosa fa ogni parte del codice di addestramento:

  • Configurazione e importazioni
  • Scarica i dati da Cloud Storage
  • Carica i dati nei panda
  • Addestra e salva il tuo modello
  • Carica il file del modello salvato in Cloud Storage

Per praticità, il codice completo per iris_training.py è ospitato su GitHub e 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 dati da Cloud Storage

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

Il codice seguente scarica i dati utilizzando gsutil, quindi li converte da gsutil a 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)

Carica i dati nei panda

Utilizza i panda per caricare i tuoi dati in 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

Creare un modulo di addestramento per AI Platform Training da eseguire. In questo esempio, il modulo di addestramento addestra un modello sui 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 ricevere 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 modello.

scikit-learn

Seguendo l'esempio di scisci-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 di raccolte di immagini, come indicato di seguito:

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

XGBoost

Puoi esportare il modello utilizzando il metodo "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 la libreria di raccolte di immagini, come indicato di seguito:

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

Requisiti di denominazione dei file modello

Per la previsione online, il file del modello salvato che carichi in Cloud Storage deve avere uno dei seguenti nomi: model.pkl, model.joblib o model.bst, a seconda della libreria utilizzata. Questa restrizione garantisce che AI Platform Prediction utilizzi lo stesso pattern per ricostruire il modello durante l'importazione 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 del modello corretto
pickle model.pkl
joblib model.joblib
xgboost.Booster model.bst

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

Carica il modello salvato in Cloud Storage

Se stai utilizzando un bucket Cloud Storage al di fuori del progetto Google Cloud che stai utilizzando 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 pacchetto di applicazioni di addestramento

Con iris_training.py creato dagli snippet riportati sopra, crea un pacchetto dell'applicazione di addestramento che includa iris_training.py come modulo principale.

Il modo più semplice (e consigliato) per creare un pacchetto di applicazione 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 dei file del pacchetto dell'applicazione di addestramento dovrebbe essere simile alla seguente:

iris_sklearn_trainer/
    __init__.py
    iris_training.py
  1. Nella riga di comando, crea una directory localmente:

    mkdir iris_sklearn_trainer
    
  2. Crea un file vuoto denominato __init__.py:

    touch iris_sklearn_trainer/__init__.py
    
  3. Salva il codice di addestramento come iris_training.py e salva il file nella directory iris_sklearn_trainer. In alternativa, utilizza 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.

  4. Verifica che il pacchetto dell'applicazione di addestramento sia configurato correttamente:

    ls ./iris_sklearn_trainer
      __init__.py  iris_training.py
    

XGBoost

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

iris_xgboost_trainer/
    __init__.py
    iris_training.py
  1. Nella riga di comando, crea una directory localmente:

    mkdir iris_xgboost_trainer
    
  2. Crea un file vuoto denominato __init__.py:

    touch iris_xgboost_trainer/__init__.py
    
  3. Salva il codice di addestramento come iris_training.py e salva il file nella directory iris_xgboost_trainer. In alternativa, utilizza 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.

  4. 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 addestramento.

Esegui il formatore localmente

Puoi testare l'applicazione di addestramento in locale 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 tuo job di addestramento in 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 tuo job di addestramento in locale:

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

Invia 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 ogni parametro nella richiesta di job di addestramento:

  • BUCKET_NAME: il nome del tuo bucket Cloud Storage.
  • JOB_NAME: un nome da utilizzare per il lavoro (solo lettere maiuscole e minuscole, numeri e trattini bassi, che inizia 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 località di 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'applicazione di addestramento. Ad esempio, ./iris_sklearn_trainer/ o ./iris_xgboost_trainer/.
  • MAIN_TRAINER_MODULE: specifica quale file deve essere eseguito dal servizio di addestramento di AI Platform Training. Il formato è [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 che utilizzi 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 area geografica.
  • 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 predefinita del cluster per le macchine per eseguire il job di addestramento. In questo caso, BASIC. Potete anche utilizzare livelli di scalabilità personalizzati per definire la configurazione del vostro cluster per l'addestramento.

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

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

Visualizzare i log di addestramento (facoltativo)

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

Per visualizzare i log del job di addestramento:

Console

  1. Apri la pagina Job di AI Platform Training.

    Apri i job nella console Google Cloud

  2. Seleziona il nome del job di addestramento da esaminare. Viene visualizzata la pagina Dettagli job per il job di addestramento selezionato.

  3. Nei dettagli del job, seleziona il link Visualizza log. Si apre la pagina Logging, dove puoi cercare e filtrare i log per il job di addestramento selezionato.

gcloud

Puoi visualizzare i log nel 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 in Cloud Storage.

gsutil ls gs://$BUCKET_NAME/iris_*

Output di esempio:

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

Passaggi successivi