Cette ancienne version d'AI Platform Training est obsolète et ne sera plus disponible sur Google Cloud après le 31 janvier 2025. Migrez vos ressources vers l'entraînement personnalisé Vertex AI pour obtenir de nouvelles fonctionnalités de machine learning qui ne sont pas disponibles dans AI Platform.

Cette page a été traduite par l'API Cloud Translation.

Entraîner un modèle de ML avec scikit-learn et XGBoost

Le service d'entraînement d'AI Platform gère les ressources informatiques disponibles dans le cloud pour l'entraînement de vos modèles. Cette page décrit le processus d'entraînement d'un modèle avec scikit-learn et XGBoost à l'aide d'AI Platform Training.

Présentation

Dans ce tutoriel, vous allez entraîner un modèle simple pour prédire des espèces de fleurs, en utilisant l'ensemble de données Iris. Après avoir ajusté le code d'entraînement de ce modèle pour télécharger des données depuis Cloud Storage, puis importé le fichier de modèle enregistré dans Cloud Storage, vous allez créer un package d'application d'entraînement qui vous servira à effectuer l'entraînement sur AI Platform Training.

Entraîner un modèle sur AI Platform Training

Une fois le processus de configuration initiale effectué, vous pouvez entraîner votre modèle sur AI Platform Training en trois étapes :

Créer le module d'entraînement Python
- Ajouter le code permettant de télécharger vos données depuis Cloud Storage afin qu'AI Platform Training puisse les utiliser.
- Une fois le modèle entraîné dans AI Platform Training, ajoutez du code pour exporter et enregistrer le modèle dans Cloud Storage.
Préparer un package d'application d'entraînement
Envoyer la tâche d'entraînement

Le processus de configuration initiale comprend la création d'un projet Google Cloud, l'activation de la facturation et des API, la configuration d'un bucket Cloud Storage à utiliser avec AI Platform Training et l'installation locale de scikit-learn ou de XGBoost. Si tout est déjà configuré et installé, passez directement à la création du code d'entraînement de votre modèle.

Avant de commencer

Procédez comme suit pour configurer un compte GCP, activer l'API AI Platform Training, puis installer et activer le SDK Cloud.

Configurer le projet GCP

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

Configurer votre environnement

Choisissez l'une des options ci-dessous pour configurer votre environnement en local sous macOS ou dans un environnement à distance sur Cloud Shell.

Pour les utilisateurs de macOS, nous vous recommandons de configurer votre environnement à l'aide de l'onglet macOS ci-dessous. Cloud Shell est disponible sous macOS, Linux et Windows (voir l'onglet Cloud Shell). Cloud Shell offre un moyen rapide d'essayer AI Platform Training, mais n'est pas adapté aux tâches de développement continu.

macOS

Vérifiez que Python est installé
Si ce n'est pas le cas, installez Python.
```
python -V
```
Vérifiez que pip est installé
pip est le gestionnaire de packages de Python, inclus dans les versions actuelles de Python. Vérifiez que pip est déjà installé en exécutant la commande pip --version. Si ce n'est pas le cas, découvrez comment installer pip.

Vous pouvez mettre à jour pip à l'aide de la commande suivante :
```
pip install -U pip
```
Pour en savoir plus, consultez la documentation sur pip.
Installez virtualenv
virtualenv est un outil permettant de créer des environnements Python isolés. Vérifiez que virtualenv est déjà installé en exécutant la commande virtualenv --version. Si ce n'est pas le cas, installez virtualenv :
```
pip install --user --upgrade virtualenv
```
Dans ce guide, pour créer un environnement de développement isolé, créez un environnement virtuel dans virtualenv. Par exemple, la commande suivante active un environnement nommé aip-env :
```
virtualenv aip-env
source aip-env/bin/activate
```
Pour les besoins de ce tutoriel, exécutez toutes les autres commandes dans votre environnement virtuel.
Obtenez plus d'informations sur l'utilisation de virtualenv. Pour quitter virtualenv, exécutez la commande deactivate.

Cloud Shell

Ouvrez Google Cloud Console.

Google Cloud Console
Cliquez sur le bouton Activer Google Cloud Shell en haut de la fenêtre de la console.

Une session Cloud Shell s'ouvre dans un nouveau cadre en bas de la console et affiche une invite de ligne de commande. L'initialisation de la session Shell peut prendre quelques secondes.

Votre session Cloud Shell est prête à l'emploi.
Configurez l'outil de ligne de commande gcloud pour qu'il utilise le projet sélectionné.
```
gcloud config set project [selected-project-id]
```
où [selected-project-id] correspond à votre ID de projet. (Saisissez-le sans les crochets.)

Installer des frameworks

macOS

Dans votre environnement virtuel, exécutez la commande suivante pour installer les versions de scikit-learn, XGBoost et pandas utilisées dans la version d'exécution 2.11 d'AI Platform Training:

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

En spécifiant les numéros de version dans la commande précédente, vous vous assurez que les dépendances de votre environnement virtuel correspondent à celles de la version d'exécution. Vous évitez ainsi tout comportement inattendu lors de l'exécution de votre code sur AI Platform Training.

Pour plus d'informations, y compris sur les options d'installation et les opérations de dépannage, reportez-vous aux instructions d'installation de chaque framework :

Cloud Shell

Exécutez la commande suivante pour installer scikit-learn, XGBoost et pandas :

pip install --user scikit-learn xgboost pandas

Pour plus d'informations, y compris sur les options d'installation et les opérations de dépannage, reportez-vous aux instructions d'installation de chaque framework :

Configurer un bucket Cloud Storage

Vous aurez besoin d'un bucket Cloud Storage pour stocker votre code d'entraînement ainsi que les dépendances. Pour les besoins de ce tutoriel, il est plus facile d'utiliser un bucket Cloud Storage dédié dans le même projet que celui utilisé pour AI Platform Training.

Si vous utilisez un bucket dans un autre projet, vous devez vous assurer que votre compte de service AI Platform Training peut accéder à votre code d'entraînement et à vos dépendances dans Cloud Storage. Sans les autorisations appropriées, votre tâche d'entraînement ne peut pas aboutir. Découvrez comment accorder des autorisations pour le stockage.

Veillez à utiliser ou à configurer un bucket situé dans la même région que celle permettant d'exécuter les tâches d'entraînement. Consultez les régions disponibles pour les services AI Platform Training.

Vous trouverez dans cette section la procédure à suivre pour créer un bucket. Vous pouvez utiliser un bucket existant, mais il doit se trouver dans la même région que celle où vous prévoyez d'exécuter des tâches AI Platform. En outre, s'il ne fait pas partie du projet que vous utilisez pour exécuter AI Platform Training, vous devez explicitement accorder l'accès aux comptes de service AI Platform Training.

Indiquez un nom pour votre nouveau bucket. Ce nom doit être unique par rapport à tous les buckets dans Cloud Storage.
```
BUCKET_NAME="YOUR_BUCKET_NAME"
```
Par exemple, vous pouvez utiliser le nom de votre projet en ajoutant -aiplatform :
```
PROJECT_ID=$(gcloud config list project --format "value(core.project)")
BUCKET_NAME=${PROJECT_ID}-aiplatform
```
Vérifiez le nom du bucket que vous avez créé.
```
echo $BUCKET_NAME
```
Sélectionnez une région pour votre bucket, puis définissez une variable d'environnement REGION.

Utilisez la même région que celle où vous prévoyez d'exécuter des tâches AI Platform Training. Consultez les régions disponibles pour les services AI Platform Training.

Par exemple, le code suivant crée la variable REGION et la définit sur us-central1 :
```
REGION=us-central1
```

Créez le bucket :

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

Créer le module d'entraînement Python

Créez un fichier iris_training.py contenant le code d'entraînement de votre modèle. Dans cette section, vous trouverez des explications sur ce que fait chaque partie du code d'entraînement :

Configuration et importation
Téléchargement des données depuis Cloud Storage
Chargement des données dans pandas
Apprentissage et enregistrement du modèle
Importation du fichier de modèle enregistré dans Cloud Storage

Pour vous faciliter la tâche, le code complet de iris_training.py est hébergé sur GitHub. Vous pouvez donc l'utiliser pour ce tutoriel :

Effectuer la configuration

Importez les bibliothèques suivantes à partir de Python et scikit-learn ou XGBoost. Définissez une variable pour le nom de votre 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>'

Importer des données depuis Cloud Storage

Au cours du processus de développement standard, vous importez vos propres données dans Cloud Storage de sorte qu'AI Platform Training puisse y accéder. Les données de ce tutoriel sont hébergées dans un bucket Cloud Storage public : gs://cloud-samples-data/ai-platform/iris/

Le code suivant télécharge les données à l'aide de gsutil, puis redirige les données de gsutil vers 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)

Charger les données dans Pandas

Chargez vos données dans des tableaux NumPy à l'aide de pandas pour pouvoir effectuer l'entraînement avec scikit-learn ou 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,))

Entraîner et enregistrer un modèle

Créez un module d'entraînement destiné à être exécuté par AI Platform Training. Dans cet exemple, le module entraîne un modèle sur les données d'entraînement Iris (iris_data et iris_target), puis enregistre le modèle entraîné en l'exportant dans un fichier. Si vous souhaitez vous servir d'AI Platform Prediction pour obtenir des prédictions en ligne après l'entraînement, vous devez nommer le fichier de modèle en fonction de la bibliothèque que vous utilisez pour l'exporter. Consultez cette section pour en savoir plus sur les règles de dénomination d'un fichier de modèle.

scikit-learn

En suivant l'exemple scikit-learn sur la persistance des modèles, vous pouvez entraîner et exporter un modèle comme indiqué ci-dessous :

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

Pour exporter le modèle, vous avez également la possibilité d'utiliser la bibliothèque pickle comme suit :

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

XGBoost

Vous pouvez exporter le modèle à l'aide de la méthode "save_model" de l'objet 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)

Pour exporter le modèle, vous avez également la possibilité d'utiliser la bibliothèque pickle comme suit :

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

Règles de dénomination des fichiers de modèle

Pour la prédiction en ligne, le fichier de modèle enregistré que vous importez dans Cloud Storage doit porter le nom suivant : model.pkl, model.joblib ou model.bst, selon la bibliothèque utilisée. Cette restriction garantit que, lors de l'importation, AI Platform Prediction reconstruit le modèle à l'aide du même schéma que celui utilisé lors de l'exportation.

Cette exigence ne s'applique pas si vous créez une routine de prédiction personnalisée (version bêta).

scikit-learn

Bibliothèque utilisée pour exporter le modèle	Nom de modèle correct
`pickle`	`model.pkl`
`sklearn.externals.joblib`	`model.joblib`

XGBoost

Bibliothèque utilisée pour exporter le modèle	Nom de modèle correct
`pickle`	`model.pkl`
`joblib`	`model.joblib`
`xgboost.Booster`	`model.bst`

Pour les futures itérations de votre modèle, organisez votre bucket Cloud Storage de sorte que chaque nouveau modèle dispose d'un répertoire dédié.

Importer le modèle enregistré dans Cloud Storage

Si vous utilisez un bucket Cloud Storage extérieur au projet Google Cloud utilisé pour exécuter AI Platform Training, vous devez vous assurer qu'AI Platform Training a bien accès à ce 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)

Créer un package d'application d'entraînement

Après avoir créé iris_training.py à l'aide des extraits ci-dessus, créez un package d'application d'entraînement incluant iris_training.py comme module principal.

La méthode la plus simple (et recommandée) pour créer un package d'application d'entraînement consiste à se servir de gcloud pour importer l'application lorsque vous envoyez la tâche d'entraînement. Cette méthode nécessite de créer une structure de fichiers très simple comprenant deux fichiers :

scikit-learn

Pour ce tutoriel, la structure de fichiers de votre package d'application d'entraînement doit se présenter comme suit :

iris_sklearn_trainer/
    __init__.py
    iris_training.py

Sur la ligne de commande, créez un répertoire en local :
```
mkdir iris_sklearn_trainer
```
Créez un fichier vide nommé __init__.py :
```
touch iris_sklearn_trainer/__init__.py
```
Enregistrez votre code d'entraînement sous le nom iris_training.py, puis enregistrez ce fichier dans votre répertoire iris_sklearn_trainer. Vous pouvez également utiliser la commande cURL pour télécharger le fichier depuis GitHub et l'enregistrer :
```
curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/sklearn/iris_training.py > iris_sklearn_trainer/iris_training.py
```
Affichez le code source complet sur GitHub.
Assurez-vous que votre package d'application d'entraînement est correctement configuré :
```
ls ./iris_sklearn_trainer
  __init__.py  iris_training.py
```

XGBoost

Pour ce tutoriel, la structure de fichiers de votre package d'application d'entraînement doit se présenter comme suit :

iris_xgboost_trainer/
    __init__.py
    iris_training.py

Sur la ligne de commande, créez un répertoire en local :
```
mkdir iris_xgboost_trainer
```
Créez un fichier vide nommé __init__.py :
```
touch iris_xgboost_trainer/__init__.py
```
Enregistrez votre code d'entraînement sous le nom iris_training.py, puis enregistrez ce fichier dans votre répertoire iris_xgboost_trainer. Vous pouvez également utiliser la commande cURL pour télécharger le fichier depuis GitHub et l'enregistrer :
```
curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/xgboost/iris_training.py > iris_xgboost_trainer/iris_training.py
```
Affichez le code source complet sur GitHub.
Assurez-vous que votre package d'application d'entraînement est correctement configuré :
```
ls ./iris_xgboost_trainer
  __init__.py  iris_training.py
```

Découvrez comment empaqueter une application d'apprentissage.

Exécuter l'application d'entraînement en local

Vous pouvez tester votre application d'entraînement en local à l'aide de la commande gcloud ai-platform local train. Bien que facultative, cette étape s'avère utile pour le débogage.

scikit-learn

Dans la ligne de commande, définissez les variables d'environnement suivantes, en remplaçant [VALUES-IN-BRACKETS] par les valeurs appropriées :

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

Testez votre tâche d'entraînement en local :

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

XGBoost

Dans la ligne de commande, définissez les variables d'environnement suivantes, en remplaçant [VALUES-IN-BRACKETS] par les valeurs appropriées :

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

Testez votre tâche d'entraînement en local :

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

Envoyer une tâche d'entraînement

Dans cette section, vous allez utiliser la commande gcloud ai-platform jobs submit training pour envoyer votre tâche d'entraînement.

Spécifier les paramètres de la tâche d'entraînement

Définissez les variables d'environnement suivantes pour chaque paramètre spécifié dans votre requête de tâche d'entraînement :

BUCKET_NAME : indiquez le nom du bucket Cloud Storage.
JOB_NAME : spécifiez le nom à utiliser pour la tâche (composé uniquement de lettres majuscules/minuscules, de chiffres et de traits de soulignement, et commençant par une lettre). Par exemple, iris_scikit_learn_$(date +"%Y%m%d_%H%M%S") ou iris_xgboost_$(date +"%Y%m%d_%H%M%S").
JOB_DIR : indiquez le chemin d'accès de l'emplacement Cloud Storage à utiliser pour les fichiers de sortie de votre tâche d'entraînement Par exemple, gs://$BUCKET_NAME/scikit_learn_job_dir ou gs://$BUCKET_NAME/xgboost_job_dir.
TRAINING_PACKAGE_PATH : spécifiez le chemin d'accès local du répertoire racine de votre application d'entraînement. Par exemple, ./iris_sklearn_trainer/ ou ./iris_xgboost_trainer/.
MAIN_TRAINER_MODULE : spécifiez le fichier que doit exécuter le service d'entraînement d'AI Platform Training. Ce fichier est au format [YOUR_FOLDER_NAME.YOUR_PYTHON_FILE_NAME]. Par exemple, iris_sklearn_trainer.iris_training ou iris_xgboost_trainer.iris_training.
REGION : spécifiez le nom de la région utilisée pour l'exécution de la tâche d'entraînement. Utilisez l'une des régions disponibles pour le service d'entraînement d'AI Platform Training. Assurez-vous que votre bucket Cloud Storage se trouve dans la même région.
RUNTIME_VERSION : spécifiez une version d'exécution d'AI Platform Training compatible avec scikit-learn. Dans cet exemple, 2.11.
PYTHON_VERSION : indiquez la version de Python à utiliser pour la tâche. Pour ce tutoriel, spécifiez Python 3.7.
SCALE_TIER : indiquez une spécification de cluster prédéfinie pour les machines appelées à exécuter votre tâche d'entraînement. Dans le cas présent : BASIC. Vous pouvez également utiliser les niveaux d'évolutivité personnalisés afin de définir votre propre configuration de cluster pour l'entraînement.

Pour plus de commodité, les variables d'environnement de ce tutoriel sont répertoriées ci-dessous.

scikit-learn

Remplacez [VALUES-IN-BRACKETS] par les valeurs appropriées :

    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

Remplacez [VALUES-IN-BRACKETS] par les valeurs appropriées :

    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

Envoyez la requête de tâche d'entraînement :

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

Un résultat semblable aux lignes suivantes doit s'afficher :

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

Afficher les journaux d'entraînement (facultatif)

AI Platform Training capture tous les flux stdout et stderr, ainsi que toutes les instructions de journalisation. Ces journaux sont stockés dans Logging, et sont visibles pendant et après l'exécution.

Pour afficher les journaux relatifs à votre tâche d'entraînement, procédez comme suit :

Console

Ouvrez la page Tâches d'AI Platform Training.

Accéder aux tâches dans la console Google Cloud
Sélectionnez le nom du job d'entraînement à inspecter. Vous accédez à la page Informations sur la tâche correspondant à la tâche d'entraînement que vous avez sélectionnée.
Dans les détails de la tâche, sélectionnez le lien Afficher les journaux. Vous accédez à la page "Journaux" permettant de rechercher et de filtrer les journaux associés à la tâche d'entraînement que vous avez sélectionnée.

gcloud

Vous pouvez afficher les journaux dans votre terminal à l'aide de la commande gcloud ai-platform jobs stream-logs.

gcloud ai-platform jobs stream-logs $JOB_NAME

Vérifier que le fichier de modèle se trouve dans Cloud Storage

Affichez le contenu du dossier du modèle de destination pour vérifier que votre fichier de modèle enregistré a été importé dans Cloud Storage.

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

Exemple de résultat :

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

Étape suivante

Obtenez des prédictions en ligne avec scikit-learn sur AI Platform Training.
Découvrez comment utiliser les niveaux d'évolutivité personnalisés afin de définir votre propre configuration de cluster pour l'entraînement.