Previsione con una pipeline scikit-learn personalizzata

Logo Colab corsa questo tutorial come blocco note in Colab Logo di GitHub Visualizza il blocco note su GitHub

Questo tutorial mostra come utilizzare AI Platform Prediction per il deployment di un progetto scikit-learn che utilizza trasformatori personalizzati.

scikit-learn pipeline consente di comporre più stimatori. Ad esempio, puoi usare i transformer per pre-elaborare i dati e passare i dati trasformati a un classificatore. Scikit-learn offre molte Transformer nel pacchetto sklearn.

Puoi anche usare lo strumento FunctionTransformer oppure TransformerMixin per creare il tuo Transformer personalizzato. Se vuoi eseguire il deployment di una pipeline che utilizza Transformer personalizzati per AI Platform Prediction, devi fornire tale codice AI Platform Prediction come distribuzione di origine pacchetto.

Questo tutorial presenta un problema di esempio relativo ai dati del censimento i seguenti passaggi:

  • Addestramento di una pipeline scikit-learn con Transformer personalizzati su AI Platform Training
  • Deployment della pipeline addestrata e del codice personalizzato su AI Platform Prediction
  • Fornisce richieste di previsione da quel deployment

Set di dati

Questo tutorial utilizza il report sul reddito del censimento degli Stati Uniti Set di dati fornite da UC Irvine Machine Learning Repository. Questo set di dati contiene informazioni su persone provenienti da un database del censimento del 1994, tra cui età, istruzione, stato civile, professione e se guadagnano più di 50.000 $l'anno.

I dati utilizzati in questo tutorial sono disponibili in un ambiente Cloud Storage pubblico del bucket: gs://cloud-samples-data/ai-platform/sklearn/census_data/

Obiettivo

L'obiettivo è addestrare una pipeline di scikit-learn che prevede se una persona guadagna più di 50.000 $all'anno (etichetta target) in base ad altri Informazioni sul censimento della persona (caratteristiche).

Questo tutorial si concentra di più sull'utilizzo di questo modello con AI Platform Prediction rispetto sulla progettazione del modello stesso. Tuttavia, è sempre importante pensare potenziali problemi e conseguenze indesiderate durante lo sviluppo del machine learning sistemi operativi. Vedi l'esercizio Crash Course sul machine learning equità per saperne di più sulle fonti di bias nel set di dati del Censimento, nonché sui modelli equità dell'apprendimento in generale.

Costi

Questo tutorial utilizza i componenti fatturabili di Google Cloud:

  • AI Platform Training
  • AI Platform Prediction
  • Cloud Storage

Scopri di più su AI Platform Training prezzi, AI Platform Prediction prezzi, e Cloud Storage prezzi, e utilizza la pagina Prezzi Calcolatrice per generare una stima dei costi in base all'utilizzo previsto.

Prima di iniziare

Devi fare diverse cose prima di poter addestrare un modello ed eseguirne il deployment AI Platform Prediction:

  • Configura il tuo ambiente di sviluppo locale.
  • Configura un progetto Google Cloud con la fatturazione e i necessari API abilitate.
  • Crea un bucket Cloud Storage per archiviare il tuo pacchetto di addestramento addestrato al modello.

Configura il tuo ambiente di sviluppo locale

Per completare questo tutorial, è necessario quanto segue:

  • Python 3
  • virtualenv
  • Google Cloud SDK

Guida di Google Cloud alla configurazione di uno sviluppo Python ambiente fornisce istruzioni dettagliate per soddisfare questi requisiti. Le seguenti i passaggi forniscono un insieme breve di istruzioni:

  1. Installa Python 3.

  2. Installa virtualenv e creerai un ambiente virtuale che utilizza Python 3.

  3. Attivare l'ambiente.

  4. Completa i passaggi nella sezione seguente per installare Google Cloud SDK.

Configura il progetto Google Cloud

  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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

    Abilita le API

  5. Install the Google Cloud CLI.

  6. To initialize the gcloud CLI, run the following command: 

    gcloud init
    7.

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

    Go to project selector

  8. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

    Abilita le API

  10. Install the Google Cloud CLI.

  11. To initialize the gcloud CLI, run the following command: 

    gcloud init
    12.

Autenticare l'account Google Cloud

Per configurare l'autenticazione, devi creare una chiave dell'account di servizio e impostare un ambiente per il percorso del file della chiave dell'account di servizio.

  1. Crea un account di servizio:

    1. Nella console Google Cloud, vai alla pagina Crea account di servizio.

      Vai a Crea account di servizio

    2. Inserisci un nome nel campo Nome account di servizio.
    3. (Facoltativo) Nel campo Descrizione account di servizio, inserisci una descrizione.
    4. Fai clic su Crea.
    5. Fai clic sul campo Seleziona un ruolo. In Tutti i ruoli, seleziona AI Platform > Amministratore AI Platform.
    6. Fai clic su Aggiungi un altro ruolo.

    7. Fai clic sul campo Seleziona un ruolo. In Tutti i ruoli, seleziona Spazio di archiviazione > Amministratore oggetti Storage.

    8. Fai clic su Fine per creare l'account di servizio.

      Non chiudere la finestra del browser. Lo utilizzerai nel passaggio successivo.

  2. Crea una chiave dell'account di servizio per l'autenticazione:

    1. Nella console Google Cloud, fai clic sull'indirizzo email dell'account di servizio è stato creato.
    2. Fai clic su Chiavi.
    3. Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.
    4. Fai clic su Crea. Sul computer viene scaricato un file della chiave JSON.
    5. Fai clic su Chiudi.

  3. Imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS al percorso del file JSON contenente la chiave dell'account di servizio. Questa variabile si applica solo alla sessione di shell corrente, quindi se apri una nuova sessione, imposta di nuovo la variabile.

Crea un bucket Cloud Storage

Questo tutorial utilizza Cloud Storage in diversi modi:

  • Quando invii un job di addestramento utilizzando Cloud SDK, carichi un file contenente il codice di addestramento in un bucket Cloud Storage. AI Platform Training esegue il codice da questo pacchetto.

  • In questo tutorial, AI Platform Training salva anche il modello addestrato risultante il tuo job nello stesso bucket.

  • Per eseguire il deployment della pipeline scikit-learn che utilizza codice personalizzato su AI Platform Prediction, devi caricare i Transformer personalizzati utilizzati dalla pipeline di archiviazione ideale in Cloud Storage.

Quando crei la risorsa della versione di AI Platform Prediction che pubblica previsioni, fornisci la pipeline scikit-learn addestrata e il codice personalizzato come URI Cloud Storage.

Imposta il nome del bucket Cloud Storage come variabile di ambiente. Deve essere univoco in tutti i bucket Cloud Storage:

BUCKET_NAME="your-bucket-name"

Seleziona una regione in cui AI Platform Training e AI Platform Prediction e creare un'altra variabile di ambiente. Ad esempio:

REGION="us-central1"

Crea il tuo bucket Cloud Storage in questa regione e, successivamente, utilizza nella stessa regione per l'addestramento e la previsione. Esegui questo comando per creare il bucket, se non esiste già:

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

Creazione di un'applicazione di addestramento e del codice della pipeline personalizzata

Crea un'applicazione per addestrare una pipeline scikit-learn con Dati del censimento. In questo tutorial, il pacchetto di addestramento contiene anche che la pipeline addestrata utilizza durante la previsione. Si tratta di una funzionalità perché le pipeline sono generalmente progettate per usare gli stessi Transformer durante l'addestramento e la previsione.

Segui questi passaggi per creare una directory che contenga tre file corrisponde alla seguente struttura:

census_package/
    __init__.py
    my_pipeline.py
    train.py

Innanzitutto, crea la directory census_package/ vuota:

mkdir census_package

All'interno di census_package/ crea un file vuoto denominato __init__.py :

touch ./census_package/__init__.py

Ciò consente di importare census_package/ come pacchetto in Python.

Crea trasformatori personalizzati

scikit-learn offre molte Transformer che puoi utilizzare come parte di una pipeline, ma ti consente anche di definire e Transformer personalizzati. Questi Transformer possono anche apprendere uno stato salvato che viene usato in un secondo momento durante la previsione.

Estendi sklearn.base.TransformerMixin per definire tre trasformatori:

  • PositionalSelector: dato un elenco di indici C e matrice M, questo restituisce una matrice con un sottoinsieme di colonne di M, indicate da C.

  • StripString: data una matrice di stringhe, vengono eliminati gli spazi bianchi da ogni stringa.

  • SimpleOneHotEncoder: un semplice one-hot codificatore che può essere applicato a una matrice di stringhe.

Per farlo, scrivi il seguente codice in un file denominato census_package/my_pipeline.py.

import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin


class PositionalSelector(BaseEstimator, TransformerMixin):
    def __init__(self, positions):
        self.positions = positions

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        return np.array(X)[:, self.positions]


class StripString(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        return self

    def transform(self, X):
        strip = np.vectorize(str.strip)
        return strip(np.array(X))


class SimpleOneHotEncoder(BaseEstimator, TransformerMixin):
    def fit(self, X, y=None):
        self.values = []
        for c in range(X.shape[1]):
            Y = X[:, c]
            values = {v: i for i, v in enumerate(np.unique(Y))}
            self.values.append(values)
        return self

    def transform(self, X):
        X = np.array(X)
        matrices = []
        for c in range(X.shape[1]):
            Y = X[:, c]
            matrix = np.zeros(shape=(len(Y), len(self.values[c])), dtype=np.int8)
            for i, x in enumerate(Y):
                if x in self.values[c]:
                    matrix[i][self.values[c][x]] = 1
            matrices.append(matrix)
        res = np.concatenate(matrices, axis=1)
        return res

Definisci la pipeline e crea il modulo di addestramento

Poi, crea un modulo di addestramento per addestrare la tua pipeline scikit-learn su Census e i dati di Google Cloud. Parte di questo codice prevede la definizione della pipeline.

Questo modulo di formazione riguarda diversi argomenti:

  • Scarica i dati di addestramento e li carica in un file DataFrame di Pandas, che può essere usato da scikit-learn.
  • Definisce la pipeline scikit-learn da addestrare. Questo esempio utilizza solo caratteristiche numeriche ('age', 'education-num' e 'hours-per-week') e tre caratteristiche categoriche ('workclass', 'marital-status' e 'relationship') dai dati di input. Trasforma le caratteristiche numeriche con gli strumenti integrati di scikit-learn StandardScaler e trasforma quelle categoriche con il codificatore one-hot personalizzato definita in my_pipeline.py. Quindi combina i dati pre-elaborati come input per un classificatore.
  • Infine, esporta il modello utilizzando la versione di joblib inclusa in scikit-learn e lo salva nel tuo bucket Cloud Storage.

Scrivi il seguente codice in census_package/train.py:

import warnings
import argparse
from google.cloud import storage

import pandas as pd
import numpy as np
from sklearn.externals import joblib
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.pipeline import Pipeline, FeatureUnion, make_pipeline
import census_package.my_pipeline as mp
warnings.filterwarnings('ignore')


def download_data(bucket_name, gcs_path, local_path):
    bucket = storage.Client().bucket(bucket_name)
    blob = bucket.blob(gcs_path)
    blob.download_to_filename(local_path)


def upload_data(bucket_name, gcs_path, local_path):
    bucket = storage.Client().bucket(bucket_name)
    blob = bucket.blob(gcs_path)
    blob.upload_from_filename(local_path)


def get_features_target(local_path):
    strip = np.vectorize(str.strip)
    raw_df = pd.read_csv(local_path, header=None)
    target_index = len(raw_df.columns) - 1  # Last columns, 'income-level', is the target

    features_df = raw_df.drop(target_index, axis=1)
    features = features_df.as_matrix()
    target = strip(raw_df[target_index].values)
    return features, target


def create_pipeline():
    # We want to use 3 categorical and 3 numerical features in this sample.
    # Categorical features: age, education-num, and hours-per-week
    # Numerical features: workclass, marital-status, and relationship
    numerical_indices = [0, 4, 12]  # age, education-num, and hours-per-week
    categorical_indices = [1, 5, 7]  # workclass, marital-status, and relationship

    p1 = make_pipeline(mp.PositionalSelector(categorical_indices), mp.StripString(), mp.SimpleOneHotEncoder())
    p2 = make_pipeline(mp.PositionalSelector(numerical_indices), StandardScaler())

    feats = FeatureUnion([
        ('numericals', p1),
        ('categoricals', p2),
    ])

    pipeline = Pipeline([
        ('pre', feats),
        ('estimator', GradientBoostingClassifier(max_depth=4, n_estimators=100))
    ])
    return pipeline


def get_bucket_path(gcs_uri):
    if not gcs_uri.startswith('gs://'):
        raise Exception('{} does not start with gs://'.format(gcs_uri))
    no_gs_uri = gcs_uri[len('gs://'):]
    first_slash_index = no_gs_uri.find('/')
    bucket_name = no_gs_uri[:first_slash_index]
    gcs_path = no_gs_uri[first_slash_index + 1:]
    return bucket_name, gcs_path


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--gcs_data_path', action="store", required=True)
    parser.add_argument('--gcs_model_path', action="store", required=True)

    arguments, others = parser.parse_known_args()

    local_path = '/tmp/adul.data'
    data_bucket, data_path = get_bucket_path(arguments.gcs_data_path)
    print('Downloading the data...')
    download_data(data_bucket, data_path, local_path)
    features, target = get_features_target(local_path)
    pipeline = create_pipeline()

    print('Training the model...')
    pipeline.fit(features, target)

    joblib.dump(pipeline, './model.joblib')

    model_bucket, model_path = get_bucket_path(arguments.gcs_model_path)
    upload_data(model_bucket, model_path, './model.joblib')
    print('Model was successfully uploaded.')

Addestramento della pipeline su AI Platform Training

Utilizza gcloud per inviare un job di addestramento ad AI Platform Training. Le seguenti pacchetti di comandi, la tua applicazione di addestramento, Cloud Storage e indica ad AI Platform Training di eseguire l'addestramento in maggior dettaglio più avanti in questo modulo.

L'argomento -- è un separatore: il servizio AI Platform Training non utilizza argomenti che seguono il separatore, ma il modulo di addestramento può comunque accedere che li rappresentano.

gcloud ai-platform jobs submit training census_training_$(date +"%Y%m%d_%H%M%S") \
  --job-dir gs://$BUCKET_NAME/custom_pipeline_tutorial/job \
  --package-path ./census_package \
  --module-name census_package.train \
  --region $REGION \
  --runtime-version 1.13 \
  --python-version 3.5 \
  --scale-tier BASIC \
  --stream-logs \
  -- \
  --gcs_data_path gs://cloud-samples-data/ai-platform/census/data/adult.data.csv \
  --gcs_model_path gs://$BUCKET_NAME/custom_pipeline_tutorial/model/model.joblib

Deployment della pipeline e pubblicazione delle previsioni

Per pubblicare previsioni da AI Platform Prediction, devi eseguire il deployment di un modello e una risorsa di versione. Il modello ti aiuta a organizzare più se modifichi e addestra la pipeline più volte. La versione che utilizza il modello addestrato e il codice personalizzato per fornire previsioni.

Per eseguire il deployment di queste risorse, devi fornire due artefatti:

  • Una directory Cloud Storage contenente la pipeline addestrata. La un job di addestramento del passaggio precedente ha creato questo file al momento dell'esportazione model.joblib al bucket.
  • Un pacchetto di distribuzione di origine .tar.gz in Cloud Storage contenente qualsiasi Transformer personalizzato utilizzato dalla pipeline. Crealo nel passaggio successivo.

Crea pacchetti di trasformatori personalizzati

Se esegui il deployment di una versione senza fornire il codice di my_pipeline.py, AI Platform Prediction non potrà importare i trasformatori personalizzati (ad esempio, mp.SimpleOneHotEncoder) e non sarà in grado di fornire previsioni.

Crea il seguente setup.py per definire un pacchetto di distribuzione di origine per il tuo codice:

import setuptools
setuptools.setup(name='census_package',
      packages=['census_package'],
      version="1.0",
      )

Quindi esegui questo comando per creare dist/census_package-1.0.tar.gz:

python setup.py sdist --formats=gztar

Infine, carica questo tarball nel tuo bucket Cloud Storage:

gcloud storage cp ./dist/census_package-1.0.tar.gz gs://$BUCKET_NAME/custom_pipeline_tutorial/code/census_package-1.0.tar.gz

Creazione di risorse per modello e versione

Innanzitutto, definisci i nomi del modello e della versione:

MODEL_NAME='CensusPredictor'
VERSION_NAME='v1'

Quindi utilizza il comando seguente per creare la risorsa del modello:

gcloud ai-platform models create $MODEL_NAME \
  --regions $REGION

Infine, crea la risorsa versione fornendo i percorsi di Cloud Storage alla directory del modello (quella che contiene model.joblib) e alla directory codice (census_package-1.0.tar.gz):

gcloud components install beta

gcloud beta ai-platform versions create $VERSION_NAME --model $MODEL_NAME \
  --origin gs://$BUCKET_NAME/custom_pipeline_tutorial/model/ \
  --runtime-version 1.13 \
  --python-version 3.5 \
  --framework SCIKIT_LEARN \
  --package-uris gs://$BUCKET_NAME/custom_pipeline_tutorial/code/census_package-1.0.tar.gz

Offerta di previsioni online

Prova il tuo deployment inviando una richiesta di previsione online. Innanzitutto, installa la libreria client dell'API di Google per Python:

pip install --upgrade google-api-python-client

Quindi invia due istanze dei dati di Census alla versione di cui hai eseguito il deployment:

import googleapiclient.discovery

instances = [
  [39, 'State-gov', 77516, ' Bachelors .  ', 13, 'Never-married', 'Adm-clerical', 'Not-in-family',
   'White', 'Male', 2174, 0, 40, 'United-States', '<=50K'],
  [50, 'Self-emp-not-inc', 83311, 'Bachelors', 13, 'Married-civ-spouse', 'Exec-managerial', 'Husband',
   'White', 'Male', 0, 0, 13, 'United-States', '<=50K']
]

service = googleapiclient.discovery.build('ml', 'v1')
name = 'projects/{}/models/{}/versions/{}'.format(PROJECT_ID, MODEL_NAME, VERSION_NAME)

response = service.projects().predict(
    name=name,
    body={'instances': instances}
).execute()

if 'error' in response:
    raise RuntimeError(response['error'])
else:
  print(response['predictions'])

La versione trasmette i dati di input attraverso la pipeline addestrata e restituisce risultati del classificatore: <=50K o >50K per ogni istanza, a seconda sulla sua previsione per la fascia di reddito della persona.

esegui la pulizia

Per eseguire la pulizia di tutte le risorse Google Cloud utilizzate in questo progetto, puoi eliminare l'account Google Cloud progetto che hai usato per il tutorial.

In alternativa, puoi pulire le singole risorse eseguendo questo :

# Delete version resource
gcloud ai-platform versions delete $VERSION_NAME --quiet --model $MODEL_NAME

# Delete model resource
gcloud ai-platform models delete $MODEL_NAME --quiet

# Delete Cloud Storage objects that were created
gcloud storage rm gs://$BUCKET_NAME/custom_pipeline_tutorial --recursive

Passaggi successivi