Previsione con una pipeline scikit-learn personalizzata

corsa questo tutorial come blocco note in Colab

Visualizza il blocco note su GitHub

Beta

Questa funzionalità è soggetta ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici dei servizi. Le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Questo tutorial mostra come utilizzare Previsione di AI Platform per eseguire il deployment di una pipeline di scikit-learn che utilizza trasformatori personalizzati.

Le pipeline di scikit-learn ti consentono 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 quel 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 in 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 diversi. 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 l'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 sono necessari i seguenti requisiti:

• Python 3
• virtualenv
• Google Cloud SDK

Nota: questo tutorial è progettato per Python 3, ma può funzionare anche con Python 2.

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. Attiva l'ambiente.

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

Configura il progetto Google Cloud

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

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the AI Platform Training & Prediction and Compute Engine APIs.

   Enable the APIs

5. Install the Google Cloud CLI.

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

   gcloud init

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

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

8. Make sure that billing is enabled for your Google Cloud project.

9. Enable the AI Platform Training & Prediction and Compute Engine APIs.

   Enable the APIs

10. Install the Google Cloud CLI.

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

    gcloud init

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. Nel campo Nome account di servizio, inserisci un nome.
   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.

      Nota: i ruoli selezionati consentono al tuo account di servizio di accedere alle risorse. Puoi visualizzare e modificare questi ruoli in un secondo momento utilizzando la console Google Cloud. Se stai sviluppando una produzione potresti dover specificare ruoli con meno autorizzazioni rispetto ad Amministratore e Amministratore oggetti Storage. Per ulteriori informazioni, consulta Controllo dell'accesso per AI Platform Prediction.

   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. Un file della chiave JSON viene scaricato sul computer.
   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.

   Esempio: Linux o macOS

   Sostituisci [PATH] con il percorso del file JSON interessato contiene la chiave dell'account di servizio.

   export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

   Ad esempio:

   export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

   Esempio: Windows

   Sostituisci [PATH] con il percorso del file JSON interessato contiene la chiave dell'account di servizio e [FILE_NAME] con nome file.

   Con PowerShell:

   $env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

   Ad esempio:

   $env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\[FILE_NAME].json"

   Con il prompt dei comandi:

   set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

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 genera le previsioni, fornisci la pipeline scikit-learn addestrata e il tuo codice personalizzato come URI di 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 il codice personalizzato utilizzato dalla pipeline addestrata 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 codificatore one-hot 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

Nota: puoi anche creare trasformatori personalizzati utilizzando sklearn.preprocessing.FunctionTransformer, ma funziona solo per le trasformazioni stateless.

Definisci la pipeline e crea un 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 Pandas che può essere usato da scikit-learn.
• Definisce la pipeline di 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.

Nota: per esportare un artefatto del modello joblib compatibile con AI Platform Prediction, devi utilizzare la versione di joblib distribuita con scikit-learn, non la versione autonoma. Per importare questa libreria in Python, utilizza l'istruzione from sklearn.externals import joblib.

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 utilizza il modello addestrato e il codice personalizzato per fornire le 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

Nota :questo pacchetto contiene anche train.py, ma la risorsa della versione no non è necessario.

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 della versione fornendo i percorsi Cloud Storage alla directory del modello (quella che contiene model.joblib) e al codice personalizzato (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 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 del censimento 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'])

Nota: questo codice utilizza le credenziali che hai impostato durante l'autenticazione passaggio per effettuare la richiesta di previsione online.

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 ripulire le singole risorse eseguendo i seguenti comandi:

# 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

• Ulteriori informazioni su come utilizzare scikit-learn personalizzato pipeline con AI Platform Prediction.
• Scopri di più sulla creazione di una routine di previsione personalizzata (beta) per un controllo ancora maggiore su come AI Platform Prediction fornisce le previsioni.