Entrena con scikit-learn en AI Platform

El servicio de capacitación de AI Platform administra los recursos de procesamiento en la nube para entrenar tus modelos. En esta página, se describe el proceso para entrenar un modelo de scikit-learn con AI Platform.

En este instructivo, se entrena un modelo simple para predecir el nivel de ingresos de una persona en función del Conjunto de datos de ingresos del censo. Debes crear una aplicación de entrenamiento de manera local, subirla a Cloud Storage y enviar un trabajo de entrenamiento. El servicio de entrenamiento de AI Platform escribe su salida en tu depósito de Cloud Storage y crea registros en Logging.

Este contenido también está disponible en GitHub como un notebook de Jupyter.

Cómo entrenar tu modelo en AI Platform

Puedes entrenar tu modelo en AI Platform en tres pasos:

  • Crea tu archivo de modelo de Python
      .
    • Agrega código para descargar tus datos desde Cloud Storage de modo que AI Platform pueda usarlos.
    • Agrega código para exportar y guardar el modelo en Cloud Storage después de que AI Platform finalice el entrenamiento del modelo.
  • Prepara un paquete de aplicación de entrenamiento.
  • Envía el trabajo de entrenamiento.

Antes de comenzar

Completa los siguientes pasos para configurar una cuenta de GCP, activar la API de AI Platform y, también, instalar y activar el SDK de Cloud.

Configura tu proyecto de GCP

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. Selecciona o crea un proyecto de GCP.

    Ir a la página Administrar recursos

  3. Asegúrate de tener habilitada la facturación para tu proyecto.

    Aprende a habilitar la facturación

  4. Habilita las AI Platform ("Cloud Machine Learning Engine") and Compute Engine API necesarias.

    Habilita las API

  5. Realiza la instalación y la inicialización del SDK de Cloud.

Configura tu entorno

Elige una de las siguientes opciones para configurar tu entorno de manera local en macOS o en un entorno remoto en Cloud Shell.

Si eres usuario de macOS, te recomendamos configurar tu entorno mediante la pestaña MACOS a continuación. Cloud Shell, que se muestra en la pestaña CLOUD SHELL, está disponible en macOS, Linux y Windows. Cloud Shell proporciona una forma rápida de probar AI Platform, pero no es adecuado para el trabajo de desarrollo continuo.

macOS

  1. Verifica la instalación de Python
    Confirma que tienes Python instalado y, si es necesario, instálalo.

    python -V
  2. Verifica la instalación de pip
    . pip es el administrador de paquetes de Python, que se incluye en las versiones actuales de Python. Para verificar si ya tienes instalado pip, ejecuta el comando pip --version. De lo contrario, consulta cómo instalar pip.

    Puedes actualizar pip con el siguiente comando:

    pip install -U pip

    Consulta la documentación de pip para obtener más detalles.

  3. Instala virtualenv
    virtualenv es una herramienta para crear entornos aislados de Python. Para verificar si ya tienes instalado virtualenv, ejecuta virtualenv --version. De lo contrario, instala virtualenv:

    pip install --user --upgrade virtualenv

    Si deseas crear un entorno de desarrollo aislado para esta guía, crea un entorno virtual nuevo en virtualenv. Por ejemplo, el siguiente comando activa un entorno llamado cmle-env:

    virtualenv cmle-env
    source cmle-env/bin/activate
  4. A los fines de este instructivo, ejecuta el resto de los comandos dentro de tu entorno virtual.

    Consulta más información sobre cómo usar virtualenv. Para salir de virtualenv, ejecuta deactivate.

Cloud Shell

  1. Abre Google Cloud Platform Console.

    Google Cloud Platform Console

  2. Haz clic en el botón Activar Google Cloud Shell en la parte superior de la ventana de la consola.

    Activar Google Cloud Shell

    Se abrirá una sesión de Cloud Shell dentro de un marco nuevo en la parte inferior de la consola que mostrará un mensaje de línea de comandos. La sesión de shell puede tardar unos segundos en inicializar.

    Sesión de Cloud Shell

    Tu sesión de Cloud Shell está lista para usarse.

  3. Configura la herramienta de línea de comandos de gcloud para que use tu proyecto seleccionado.

    gcloud config set project [selected-project-id]

    donde [selected-project-id] es el ID del proyecto. (Omite los corchetes).

Verifica los componentes del SDK de Google Cloud

Para verificar que los componentes del SDK de Google Cloud están instalados, realiza lo siguiente:

  1. Genera una lista de tus modelos con el siguiente comando:

    gcloud ai-platform models list
  2. Si no has creado ningún modelo anteriormente, el comando muestra una lista vacía:

    Listed 0 items.

    Después de comenzar a crear modelos, puedes verlos en una lista con este comando.

  3. Si ya instalaste gcloud, actualiza con el siguiente comando:

    gcloud components update

Instala marcos de trabajo

macOS

Dentro de tu entorno virtual, ejecuta el siguiente comando para instalar las versiones de scikit-learn y Pandas que se usan en la versión 1.14 del entorno de ejecución de AI Platform:

(cmle-env)$ pip install scikit-learn==0.20.2 pandas==0.24.0

Cuando proporciones los números de versión en el comando anterior, asegúrate de que las dependencias de tu entorno virtual coincidan con las dependencias de la versión del entorno de ejecución. Esto ayuda a prevenir comportamientos inesperados cuando tu código se ejecuta en AI Platform.

Para obtener más detalles, información de solución de problemas y opciones de instalación, consulta las siguientes instrucciones de instalación para cada marco de trabajo:

Cloud Shell

Ejecuta el siguiente comando para instalar scikit-learn y Pandas:

pip install --user scikit-learn pandas

Para obtener más detalles, información de solución de problemas y opciones de instalación, consulta las siguientes instrucciones de instalación para cada marco de trabajo:

Configura tu depósito de Cloud Storage

Necesitarás un depósito de Cloud Storage para almacenar tu código de entrenamiento y dependencias. Para los fines de este instructivo, es más fácil usar un depósito de Cloud Storage dedicado en el mismo proyecto que usas para AI Platform.

Si usas un depósito en un proyecto diferente, debes asegurarte de que puedes acceder con tu cuenta de servicio de AI Platform a tu código de entrenamiento y a las dependencias en Cloud Storage. Sin los permisos adecuados, tu trabajo de entrenamiento falla. Consulta cómo otorgar permisos para el almacenamiento.

Asegúrate de usar o configurar un depósito en la misma región que usas para ejecutar tus trabajos de entrenamiento. Consulta las regiones disponibles para los servicios de AI Platform.

En esta sección, se muestra cómo crear un depósito nuevo. Puedes usar un depósito existente, pero debe estar en la misma región en la que planeas ejecutar los trabajos de AI Platform. Además, si no forma parte del proyecto que usas para ejecutar AI Platform, debes otorgar acceso a las cuentas de servicio de AI Platform de forma explícita.

  1. Especifica un nombre para tu depósito nuevo. El nombre debe ser único entre todos los depósitos en Cloud Storage.

    BUCKET_NAME="your_bucket_name"

    Por ejemplo, usa el nombre de tu proyecto con -mlengine agregado:

    PROJECT_ID=$(gcloud config list project --format "value(core.project)")
    BUCKET_NAME=${PROJECT_ID}-mlengine
  2. Comprueba el nombre del depósito que creaste.

    echo $BUCKET_NAME
  3. Selecciona una región para tu depósito y establece una variable de entorno REGION.

    Usa la misma región en la que planeas ejecutar los trabajos de AI Platform. Consulta las regiones disponibles para servicios de AI Platform.

    Por ejemplo, con el siguiente código se crea una REGION y se configura como us-central1:

    REGION=us-central1
  4. Crea el depósito nuevo con el siguiente comando:

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

Acerca de los datos

El Conjunto de datos de ingresos del censo que se usa en este ejemplo para el entrenamiento está alojado en el UC Irvine Machine Learning Repository.

Los datos del censo son cortesía de Lichman, M. (2013). UCI Machine Learning Repository http://archive.ics.uci.edu/ml. Irvine, CA: University of California, School of Information and Computer Science. Este conjunto de datos está disponible públicamente para que cualquier persona lo use según los siguientes términos proporcionados por la fuente del conjunto de datos, http://archive.ics.uci.edu/ml, y se ofrece “TAL CUAL” sin ninguna garantía, expresa o implícita, de Google. Google renuncia a toda responsabilidad por cualquier daño, directo o indirecto, que resulte del uso del conjunto de datos.

Para tu comodidad, alojamos los datos en un depósito público de Cloud Storage, gs://cloud-samples-data/ai-platform/sklearn/census_data/, que puedes descargar en tu archivo de entrenamiento de Python.

Crea tu archivo de modelo de Python

Puedes encontrar todo el código de entrenamiento para esta sección en GitHub: train.py.

En el resto de esta sección, se proporciona una explicación de lo que hace el código de entrenamiento.

Configuración

Importa las siguientes bibliotecas desde Python, SDK de Cloud y scikit-learn. Configura una variable para el nombre de tu depósito de Cloud Storage.

import datetime
import pandas as pd

from google.cloud import storage

from sklearn.ensemble import RandomForestClassifier
from sklearn.externals import joblib
from sklearn.feature_selection import SelectKBest
from sklearn.pipeline import FeatureUnion
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import LabelBinarizer

# TODO: REPLACE 'YOUR_BUCKET_NAME' with your GCS Bucket name.
BUCKET_NAME = 'YOUR_BUCKET_NAME'

Descarga los datos desde Cloud Storage

Durante el proceso de desarrollo típico, subes tus propios datos a Cloud Storage para que AI Platform pueda acceder a ellos. Los datos de este instructivo están alojados en un depósito público en gs://cloud-samples-data/ai-platform/sklearn/census_data/.

El siguiente código descarga el conjunto de datos de entrenamiento adult.data. (Los datos de evaluación están disponibles en adult.test, pero no se usan en este instructivo).

# Public bucket holding the census data
bucket = storage.Client().bucket('cloud-samples-data')

# Path to the data inside the public bucket
blob = bucket.blob('ai-platform/sklearn/census_data/adult.data')
# Download the data
blob.download_to_filename('adult.data')

Agrega el código del modelo

El código de entrenamiento de modelos lleva a cabo algunos pasos básicos:

  • Define y carga datos.
  • Convertir funciones categóricas en funciones numéricas.
  • Extraer funciones numéricas con una canalización de scikit-learn.
  • Exporta y guarda el modelo en Cloud Storage.

Define y carga datos.

# Define the format of your input data including unused columns (These are the columns from the census data files)
COLUMNS = (
    'age',
    'workclass',
    'fnlwgt',
    'education',
    'education-num',
    'marital-status',
    'occupation',
    'relationship',
    'race',
    'sex',
    'capital-gain',
    'capital-loss',
    'hours-per-week',
    'native-country',
    'income-level'
)

# Categorical columns are columns that need to be turned into a numerical value to be used by scikit-learn
CATEGORICAL_COLUMNS = (
    'workclass',
    'education',
    'marital-status',
    'occupation',
    'relationship',
    'race',
    'sex',
    'native-country'
)

# Load the training census dataset
with open('./adult.data', 'r') as train_data:
    raw_training_data = pd.read_csv(train_data, header=None, names=COLUMNS)

# Remove the column we are trying to predict ('income-level') from our features list
# Convert the Dataframe to a lists of lists
train_features = raw_training_data.drop('income-level', axis=1).values.tolist()
# Create our training labels list, convert the Dataframe to a lists of lists
train_labels = (raw_training_data['income-level'] == ' >50K').values.tolist()

Convierte atributos categóricos en atributos numéricos

# Since the census data set has categorical features, we need to convert
# them to numerical values. We'll use a list of pipelines to convert each
# categorical column and then use FeatureUnion to combine them before calling
# the RandomForestClassifier.
categorical_pipelines = []

# Each categorical column needs to be extracted individually and converted to a numerical value.
# To do this, each categorical column will use a pipeline that extracts one feature column via
# SelectKBest(k=1) and a LabelBinarizer() to convert the categorical value to a numerical one.
# A scores array (created below) will select and extract the feature column. The scores array is
# created by iterating over the COLUMNS and checking if it is a CATEGORICAL_COLUMN.
for i, col in enumerate(COLUMNS[:-1]):
    if col in CATEGORICAL_COLUMNS:
        # Create a scores array to get the individual categorical column.
        # Example:
        #  data = [39, 'State-gov', 77516, 'Bachelors', 13, 'Never-married', 'Adm-clerical',
        #         'Not-in-family', 'White', 'Male', 2174, 0, 40, 'United-States']
        #  scores = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
        #
        # Returns: [['State-gov']]
        # Build the scores array.
        scores = [0] * len(COLUMNS[:-1])
        # This column is the categorical column we want to extract.
        scores[i] = 1
        skb = SelectKBest(k=1)
        skb.scores_ = scores
        # Convert the categorical column to a numerical value
        lbn = LabelBinarizer()
        r = skb.transform(train_features)
        lbn.fit(r)
        # Create the pipeline to extract the categorical feature
        categorical_pipelines.append(
            ('categorical-{}'.format(i), Pipeline([
                ('SKB-{}'.format(i), skb),
                ('LBN-{}'.format(i), lbn)])))

Extrae atributos numéricos con una canalización de scikit-learn

# Create pipeline to extract the numerical features
skb = SelectKBest(k=6)
# From COLUMNS use the features that are numerical
skb.scores_ = [1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0]
categorical_pipelines.append(('numerical', skb))

# Combine all the features using FeatureUnion
preprocess = FeatureUnion(categorical_pipelines)

# Create the classifier
classifier = RandomForestClassifier()

# Transform the features and fit them to the classifier
classifier.fit(preprocess.transform(train_features), train_labels)

# Create the overall model as a single pipeline
pipeline = Pipeline([
    ('union', preprocess),
    ('classifier', classifier)
])

Exporta y guarda el modelo en Cloud Storage

Si tu depósito de Cloud Storage se encuentra en el mismo proyecto que estás utilizando para AI Platform, entonces AI Platform puede leer desde tu depósito y escribir en él. De no ser así, debes asegurarte de que el proyecto que estás utilizando para ejecutar AI Platform tenga acceso a tu depósito de Cloud Storage. Consulta cómo otorgar permisos para el almacenamiento.

Asegúrate de asignar a tu archivo de modelo el nombre model.pkl o model.joblib si deseas usarlo para solicitar predicciones en línea con AI Platform.

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

# Upload the model to GCS
bucket = storage.Client().bucket(BUCKET_NAME)
blob = bucket.blob('{}/{}'.format(
    datetime.datetime.now().strftime('census_%Y%m%d_%H%M%S'),
    model))
blob.upload_from_filename(model)

Verifica la carga del archivo de modelo en Cloud Storage (opcional)

En la línea de comandos, visualiza los contenidos de la carpeta del modelo de destino para verificar que tu archivo de modelo se haya subido a Cloud Storage. Configura una variable de entorno (BUCKET_ID) para el nombre de tu depósito, si aún no lo has hecho.

gsutil ls gs://$BUCKET_ID/census_*

El resultado debería ser similar al ejemplo siguiente:

gs://[YOUR-PROJECT-ID]/census_[DATE]_[TIME]/model.joblib

Crea un paquete de aplicación de entrenamiento

La forma más fácil (y recomendada) de crear un paquete de aplicación de entrenamiento usa gcloud para empaquetar y subir la aplicación cuando envías tu trabajo de entrenamiento. Este método te permite crear una estructura de archivos muy simple con solo dos archivos. Para este instructivo, la estructura del archivo de tu paquete de aplicación de entrenamiento debe ser similar a la siguiente:

census_training/
    __init__.py
    train.py
  1. Crea un directorio de manera local:

    mkdir census_training
    
  2. Crea un archivo en blanco llamado __init__.py:

    touch census_training/__init__.py
    
  3. Guarda tu código de entrenamiento en un archivo de Python, y guarda ese archivo en tu directorio census_training. Consulta el código de ejemplo para train.py. Puedes usar cURL para descargar y guardar el archivo:

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/cloudml-samples/master/sklearn/notebooks/census_training/train.py > census_training/train.py
    

Obtén más información sobre cómo empaquetar una aplicación de entrenamiento.

Envía el trabajo de entrenamiento

En esta sección, usarás gcloud ai-platform jobs submit training para enviar tu trabajo de entrenamiento.

Especifica los parámetros del trabajo de entrenamiento

Configura las siguientes variables de entorno para cada parámetro en tu solicitud de trabajo de entrenamiento:

  • PROJECT_ID: usa el PROJECT_ID que coincida con tu proyecto de Google Cloud Platform.
  • BUCKET_ID: es el nombre de tu depósito de Cloud Storage.
  • JOB_NAME: es un nombre para el trabajo (combinaciones de mayúsculas y minúsculas, números y guiones bajos únicamente, que comience con una letra). En este caso, es census_training_$(date +"%Y%m%d_%H%M%S").
  • JOB_DIR: es la ruta a una ubicación de Cloud Storage para tus archivos de salida del trabajo de entrenamiento. Por ejemplo, gs://$BUCKET_ID/scikit_learn_job_dir.
  • TRAINING_PACKAGE_PATH: es la ruta local al directorio raíz de tu aplicación de entrenamiento. En este caso, es ./census_training/.
  • MAIN_TRAINER_MODULE: especifica qué archivo debe ejecutar el servicio de entrenamiento de AI Platform. Tiene el formato [YOUR_FOLDER_NAME.YOUR_PYTHON_FILE_NAME]. En este caso, es census_training.train.
  • REGION: es el nombre de la región que usas para ejecutar tu trabajo de entrenamiento. Usa una de las regiones disponibles para el servicio de entrenamiento de AI Platform. Asegúrate de que tu depósito de Cloud Storage esté en la misma región.
  • RUNTIME_VERSION: es una versión del entorno de ejecución de AI Platform que debes especificar que sea compatible con scikit-learn. En este ejemplo, es 1.14.
  • PYTHON_VERSION: es la versión de Python que se usa para el trabajo. Python 3.5 está disponible para la versión 1.4 o superior de AI Platform. Si no especificas una versión de Python, el servicio de entrenamiento usa Python 2.7. Para este instructivo, especifica Python 2.7.
  • SCALE_TIER: es una especificación del clúster predefinida para que las máquinas ejecuten tu trabajo de entrenamiento. En este caso, es BASIC. También puedes usar niveles de escala personalizados a fin de definir tu propia configuración del clúster para el entrenamiento.

Para tu comodidad, a continuación se detallan las variables de entorno que se usan en este instructivo. Reemplaza [VALUES-IN-BRACKETS] por los valores adecuados como se muestra a continuación:

PROJECT_ID=[YOUR-PROJECT-ID]
BUCKET_ID=[YOUR-BUCKET-ID]
JOB_NAME=census_training_$(date +"%Y%m%d_%H%M%S")
JOB_DIR=gs://$BUCKET_ID/scikit_learn_job_dir
TRAINING_PACKAGE_PATH="[YOUR-LOCAL-PATH-TO-TRAINING-PACKAGE]/census_training/"
MAIN_TRAINER_MODULE=census_training.train
REGION=us-central1
RUNTIME_VERSION=1.14
PYTHON_VERSION=2.7
SCALE_TIER=BASIC

Envía la solicitud:

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

Deberías ver un resultado similar al siguiente:

Job [census_training_[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 census_training_[DATE]_[TIME]

or continue streaming the logs with the command

  $ gcloud ai-platform jobs stream-logs census_training_[DATE]_[TIME]
jobId: census_training_[DATE]_[TIME]
state: QUEUED

Visualiza tus registros de entrenamiento (opcional)

AI Platform captura todas las transmisiones stdout y stderr y las instrucciones de registro. Estos registros se almacenan en Logging y son visibles tanto durante como después de la ejecución.

Para visualizar los registros de tu trabajo de entrenamiento, sigue estos pasos:

Console

  1. Abre la página Trabajos de AI Platform.

    Abrir trabajos en GCP Console

  2. Selecciona el nombre del trabajo de entrenamiento para inspeccionar. Esto te lleva a la página Detalles del trabajo de tu trabajo de entrenamiento seleccionado.

  3. Dentro de los detalles del trabajo, selecciona el vínculo Ver registros. Esto te lleva a la página Logging donde puedes buscar y filtrar los registros para tu trabajo de entrenamiento seleccionado.

gcloud

Puedes ver los registros en tu terminal con gcloud ai-platform jobs stream-logs.

gcloud ai-platform jobs stream-logs $JOB_NAME

Qué sigue

¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

¿Necesitas ayuda? Visita nuestra página de asistencia.