Previsione del lifetime value cliente con AutoML Tables

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questo articolo è la quarta parte di una serie in quattro parti che illustra come è possibile prevedere il lifetime value cliente (CLV) utilizzando AI Platform (AI Platform) su Google Cloud. Questo articolo illustra come utilizzare le tabelle AutoML per eseguire le previsioni.

Gli articoli di questa serie includono:

  • Parte 1 - Introduzione. Introduce il CLV e due tecniche di modellazione per prevedere il CLV.
  • Parte 2 - Addestramento del modello: illustra come preparare i dati e addestrare i modelli.
  • Parte 3 - Deployment in produzione. Descrive come eseguire il deployment dei modelli illustrati nella Parte 2 in un sistema di produzione.
  • Parte 4: Utilizzo di AutoML Tables (articolo in questo articolo). Mostra come utilizzare AutoML Tables per creare un modello ed eseguirne il deployment.

Il processo descritto in questo articolo si basa sugli stessi passaggi di elaborazione dei dati di BigQuery descritti nella Parte 2 della serie. Questo articolo illustra come caricare il set di dati BigQuery in AutoML Tables e creare un modello. Questo articolo mostra anche come integrare il modello AutoML nel sistema di produzione descritto nella Parte 3.

Il codice per l'implementazione di questo sistema si trova nello stesso repository di GitHub della serie originale. Questo articolo illustra come utilizzare il codice per le AutoML Tables nel repository.

Vantaggi di AutoML Tables

Nelle parti precedenti della serie, hai visto come prevedere il CLV utilizzando sia un modello statistico che un modello DNN implementato in TensorFlow. Le tabelle AutoML presentano numerosi vantaggi rispetto agli altri due metodi:

  • Non è richiesta alcuna programmazione per creare il modello È disponibile una UI della console che ti consente di creare, addestrare, gestire ed eseguire il deployment di set di dati e modelli.
  • L'aggiunta o la modifica di funzionalità è facile e può essere eseguita direttamente nell'interfaccia della console.
  • Il processo di addestramento è automatizzato, incluso l'ottimizzazione degli iperparametri.
  • AutoML Tables cerca la migliore architettura per il tuo set di dati, eliminando la necessità di scegliere tra le numerose opzioni disponibili.
  • AutoML Tables fornisce un'analisi dettagliata delle prestazioni di un modello addestrato, inclusa l'importanza delle caratteristiche.

Di conseguenza, lo sviluppo e l'addestramento di un modello completamente ottimizzato utilizzando AutoML Tables possono richiedere tempo e costi.

Un deployment in produzione di una soluzione AutoML Tables richiede l'utilizzo dell'API client Python per creare ed eseguire il deployment di modelli ed eseguire previsioni. Questo articolo spiega come creare e addestrare modelli AutoML Tables con l'API client. Per istruzioni su come eseguire questi passaggi utilizzando la console AutoML Tables, consulta la documentazione di AutoML Tables.

Installare il codice

Se non hai installato il codice per la serie originale, segui gli stessi passaggi descritti nella Parte 2 della serie originale per installare il codice. Il file README nel repository GitHub descrive tutti i passaggi necessari per preparare il tuo ambiente, installare il codice e configurare AutoML Tables nel tuo progetto.

Se hai già installato il codice, devi completare questi passaggi aggiuntivi per completare l'installazione di questo articolo:

  1. Abilita l'API AutoML Tables nel tuo progetto.
  2. Attiva l'ambiente miniconda che hai installato in precedenza.
  3. Installa la libreria client Python come descritto nella documentazione di AutoML Tables.
  4. Crea e scarica un file chiave API e salvalo in una posizione nota da utilizzare in un secondo momento con la libreria client.

Eseguire il codice

Per molti dei passaggi descritti in questo articolo, esegui comandi Python. Dopo aver preparato l'ambiente e installato il codice, hai a disposizione le opzioni seguenti per eseguire il codice:

  • Esegui il codice in un blocco note Jupyter. Dalla finestra del terminale nell'ambiente miniconda attivato, esegui il comando seguente:

    $ (clv) jupyter notebook

    Il codice per ognuno dei passaggi in questo articolo si trova in un blocco note nel repository del codice denominato notebooks/clv_automl.ipynb. Apri questo blocco note nell'interfaccia di Jupyter. Puoi quindi eseguire ciascuno dei passaggi man mano che segui il tutorial.

  • Esegui il codice come script Python. I passaggi del codice per questo tutorial sono nel repository del codice nel file clv_automl/clv_automl.py. Lo script prende argomenti nella riga di comando per parametri configurabili come l'ID progetto, la posizione del file della chiave API, l'area geografica di Google Cloud e il nome del set di dati BigQuery. Esegui lo script dalla finestra del terminale nell'ambiente miniconda attivato, sostituendo il nome del progetto Google Cloud con [YOUR_PROJECT]:

    $ (clv) cd clv_automl
$ (clv) python clv_automl.py --project_id [YOUR_PROJECT]

    Per l'elenco completo dei parametri e dei valori predefiniti, consulta il metodo create_parser nello script oppure esegui lo script senza argomenti per visualizzare la documentazione sull'utilizzo.

  • Dopo aver installato l'ambiente Cloud Composer come descritto nel file README, esegui il codice eseguendo i DAG, come descritto più avanti nella sezione Esecuzione dei DAG.

Preparazione dei dati

Questo articolo utilizza gli stessi passaggi di preparazione del set di dati e di dati descritti in Parte 2 della serie originale in BigQuery. Dopo aver completato l'aggregazione dei dati come descritto in questo articolo, puoi creare un set di dati da utilizzare con AutoML Tables.

Creazione del set di dati AutoML Tables

Per iniziare, carica i dati che hai preparato in BigQuery in AutoML Tables.

  1. Per inizializzare il client, imposta il nome del file della chiave sul nome del file che hai scaricato nel passaggio di installazione:

    keyfile_name = "mykey.json"
client = automl_v1beta1.AutoMlClient.from_service_account_file(keyfile_name)

  2. Crea il set di dati:

    create_dataset_response = client.create_dataset(
    location_path,
    {'display_name': dataset_display_name,
     'tables_dataset_metadata': {}})
dataset_name = create_dataset_response.name

Importazione dei dati da BigQuery

Dopo aver creato il set di dati, puoi importare i dati da BigQuery.

  • Importa i dati da BigQuery nel set di dati AutoML Tables:

    dataset_bq_input_uri = 'bq://{}.{}.{}'.format(args.project_id, args.bq_dataset, args.bq_table)
input_config = {
    'bigquery_source': {
        'input_uri': dataset_bq_input_uri}}
import_data_response = client.import_data(dataset_name, input_config)

Addestramento del modello

Dopo aver creato il set di dati AutoML per i dati CLV, puoi creare il modello AutoML Tables.

  1. Ottieni le specifiche della colonna AutoML Tables per ogni colonna nel set di dati:

    list_table_specs_response = client.list_table_specs(dataset_name)
table_specs = [s for s in list_table_specs_response]
table_spec_name = table_specs[0].name
list_column_specs_response = client.list_column_specs(table_spec_name)
column_specs = {s.display_name: s for s in list_column_specs_response}

    Le specifiche della colonna sono necessarie nei passaggi successivi.

  2. Assegna una delle colonne come etichetta del modello AutoML Tabless:

    TARGET_LABEL = 'target_monetary'
...
label_column_name = TARGET_LABEL
label_column_spec = column_specs[label_column_name]
label_column_id = label_column_spec.name.rsplit('/', 1)[-1]
update_dataset_dict = {
    'name': dataset_name,
    'tables_dataset_metadata': {
        'target_column_spec_id': label_column_id
    }
}
update_dataset_response = client.update_dataset(update_dataset_dict)

    Questo codice utilizza la stessa colonna di etichetta (target_monetary) del modello DNN di TensorFlow nella parte 2.

  3. Definisci le funzionalità per addestrare il modello:

    feat_list = list(column_specs.keys())
feat_list.remove('target_monetary')
feat_list.remove('customer_id')
feat_list.remove('monetary_btyd')
feat_list.remove('frequency_btyd')
feat_list.remove('frequency_btyd_clipped')
feat_list.remove('monetary_btyd_clipped')
feat_list.remove('target_monetary_clipped')

    Le funzionalità utilizzate per addestrare il modello AutoML Tables sono le stesse utilizzate per addestrare il modello TensorFlow DNN nella Parte 2 della serie originale. Tuttavia, l'aggiunta o la sottrazione di funzionalità dal modello è molto più semplice con AutoML Tables. Una funzionalità creata in BigQuery viene inclusa automaticamente nel modello, a meno che non la rimuovi esplicitamente come mostrato nello snippet di codice precedente.

  4. Definisci le opzioni per la creazione del modello. Per questo set di dati è consigliato l'obiettivo di ottimizzazione la riduzione al minimo dell'errore medio assoluto, rappresentato dal parametro MINIMIZE_MAE.

    model_display_name = args.automl_model
model_training_budget = args.training_budget * 1000
model_dict = {
  'display_name': model_display_name,
  'dataset_id': dataset_name.rsplit('/', 1)[-1],
  'tables_model_metadata': {
      'target_column_spec': column_specs['target_monetary'],
      'input_feature_column_specs': [
          column_specs[x] for x in feat_list],
      'train_budget_milli_node_hours': model_training_budget,
      'optimization_objective': 'MINIMIZE_MAE'
  }
}

    Per saperne di più, consulta la documentazione di AutoML Tables sugli obiettivi di ottimizzazione.

  5. Crea il modello e avvia l'addestramento:

    create_model_response = client.create_model(location_path, model_dict)
create_model_result = create_model_response.result()
model_name = create_model_result.name

    Il valore restituito dalla chiamata client (create_model_response) viene immediatamente restituito. Il valore create_model_response.result() è una promessa, che si blocca fino al completamento dell'addestramento. Il valore model_name è un percorso della risorsa necessario per ulteriori chiamate del client che operano sul modello.

Valutazione del modello

Una volta completato l'addestramento del modello, puoi recuperare le statistiche di valutazione del modello. Puoi utilizzare la console Google Cloud o l'API client.

  1. Per utilizzare la console, nella console AutoML Tables vai alla scheda Valuta:

    Valuta la scheda della console AutoML Tables

  2. Per utilizzare l'API client, recupera le statistiche di valutazione del modello:

    model_evaluations = [e for e in client.list_model_evaluations(model_name)]
model_evaluation = model_evaluations[0]

    L'output visualizzato è simile al seguente:

    name: "projects/595920091534/locations/us-central1/models/TBL3912308662231629824/modelEvaluations/9140437057533851929"
create_time {
  seconds: 1553108019
  nanos: 804478000
}
evaluated_example_count: 125
regression_evaluation_metrics: {
  mean_absolute_error: 591.091
  root_mean_squared_error: 853.481
  mean_absolute_percentage_error: 21.47
  r_squared: 0.907
}

L'errore quadratico medio radice di 853.481 viene confrontato favorevolmente con i modelli professionali e TensorFlow utilizzati nella serie originale. Tuttavia, come discusso nella parte 2, è consigliabile provare ciascuna delle tecniche fornite con i dati per verificare quale ha il rendimento migliore.

Deployment del modello AutoML

I DAG di Cloud Composer della serie originale sono stati aggiornati per includere il modello AutoML Tables sia per l'addestramento che per la previsione. Per informazioni generali sul funzionamento dei DAG di Cloud Composer, consulta la sezione sull'automazione della soluzione nella parte 3 degli articoli originali.

Per installare questa soluzione, puoi installare il sistema di orchestrazione Cloud Composer seguendo le istruzioni nel README.

I metodi di chiamata DAG aggiornati nello script clv_automl/clv_automl.py che replicano le chiamate al codice client mostrate in precedenza per creare il modello ed eseguire previsioni.

Il DAG per l'addestramento

Il DAG aggiornato per l'addestramento include attività per creare un modello AutoML Tables. Il seguente diagramma mostra il nuovo DAG per l'addestramento.

Addestramento DAG

Il DAG di previsione

Il DAG aggiornato per la previsione include le attività per eseguire previsioni batch con il modello AutoML Tables. Il seguente diagramma mostra il nuovo DAG per le previsioni.

DAG previsioni

Esecuzione dei DAG

Per attivare manualmente i DAG, puoi eseguire i comandi dalla sezione Esegui Dags del file README in Cloud Shell o utilizzando Google Cloud CLI.

  1. Per eseguire il DAG build_train_deploy:

    gcloud composer environments run ${COMPOSER_NAME} \
    --project ${PROJECT} \
    --location ${REGION} \
    dags trigger \
    -- \
    build_train_deploy \
    --conf '{"model_type":"automl", "project":"'${PROJECT}'", "dataset":"'${DATASET_NAME}'", "threshold_date":"2011-08-08", "predict_end":"2011-12-12", "model_name":"automl_airflow", "model_version":"v1", "max_monetary":"15000"}'

  2. Esegui il DAG predict_serve:

    gcloud composer environments run ${COMPOSER_NAME} \
    --project ${PROJECT} \
    --location ${REGION} \
    dags trigger \
    -- \
    predict_serve \
    --conf '{"model_name":"automl_airflow", "model_version":"v1", "dataset":"'${DATASET_NAME}'"}'

Passaggi successivi