Prevedere il lifetime value cliente con le tabelle AutoML

Last reviewed 2019-04-10 UTC

Questo articolo è la quarta parte di una serie di quattro parti che spiega come prevedere il lifetime value cliente (CLV) utilizzando AI Platform (AI Platform) su Google Cloud. Questo articolo mostra 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 la previsione del CLV.
  • Parte 2: addestramento del modello Discute 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 (questo articolo). Mostra come utilizzare le tabelle AutoML per creare ed eseguire il deployment di un modello.

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

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

Vantaggi di AutoML Tables

Nelle parti precedenti della serie hai visto come prevedere il CLV utilizzando un modello statistico e un modello DNN implementato in TensorFlow. Le tabelle AutoML hanno diversi vantaggi rispetto agli altri due metodi:

  • Per creare il modello non è necessario scrivere codice. Esiste una UI di console che ti consente di creare, addestrare, gestire ed eseguire il deployment di set di dati e modelli.
  • È facile aggiungere o modificare funzionalità, direttamente nell'interfaccia della console.
  • Il processo di addestramento è automatizzato, inclusa l'ottimizzazione degli iperparametri.
  • AutoML Tables ricerca la migliore architettura per il tuo set di dati, sollevandoti dalla necessità di scegliere tra le numerose opzioni disponibili.
  • AutoML Tables fornisce un'analisi dettagliata delle prestazioni di un modello addestrato, inclusa l'importanza delle funzionalità.

Di conseguenza, sviluppare e addestrare un modello completamente ottimizzato può richiedere meno tempo e costi.

Il 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 mostra come creare e addestrare i modelli AutoML Tables utilizzando l'API client. Per indicazioni 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 installarlo. Il file README nel repository GitHub descrive tutti i passaggi necessari per preparare l'ambiente, installare il codice e configurare AutoML Tables nel progetto.

Se hai già installato il codice, devi completare questi passaggi aggiuntivi per completare l'installazione per 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 per utilizzarlo in seguito con la libreria client.

Esecuzione del codice

Per la maggior parte dei passaggi di questo articolo, esegui i 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 questo comando:

    $ (clv) jupyter notebook

    Il codice per ognuno dei passaggi in questo articolo è in un blocco note nel repository di 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 di codice nel file clv_automl/clv_automl.py. Lo script accetta nella riga di comando argomenti per parametri configurabili come ID progetto, posizione del file della chiave API, area geografica Google Cloud e nome del set di dati BigQuery. Esegui lo script dalla finestra del terminale nell'ambiente miniconda attivato, sostituendo il tuo nome progetto Google Cloud per [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 in README, esegui il codice eseguendo i DAG, come descritto di seguito in Esecuzione dei DAG.

Preparazione dei dati

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

Creazione del set di dati AutoML Tables

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

  1. Per inizializzare il client, imposta il nome del file della chiave sul nome del file che hai scaricato durante il 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 Tabelle AutoML.

  1. Ottieni le specifiche delle colonne 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 per il modello AutoML Tables:

    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 etichette (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 caratteristiche dal modello è molto più semplice con AutoML Tables. Una volta creata in BigQuery, una funzionalità 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. L'obiettivo di ottimizzazione della riduzione al minimo dell'errore medio assoluto, rappresentato dal parametro MINIMIZE_MAE, è consigliato per questo set di dati.

    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 ulteriori informazioni, consulta la documentazione di AutoML Tables sugli obiettivi di ottimizzazione.

  5. Crea il modello e inizia 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 risorsa necessario per ulteriori chiamate client che operano sul modello.

Valutazione del modello in corso...

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

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

    Scheda Valuta 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]

    Vedrai un output 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 della radice 853.481 mette a confronto i modelli probabilistici e TensorFlow utilizzati nella serie originale. Tuttavia, come spiegato nella parte 2, è consigliabile provare ciascuna delle tecniche fornite con i dati per vedere quale funziona meglio.

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

Puoi installare il sistema di orchestrazione Cloud Composer per questa soluzione seguendo le istruzioni nell'articolo README.

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

Il DAG di 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.

DAG di addestramento

Il DAG di previsione

Il DAG aggiornato per la previsione include le attività per l'esecuzione di previsioni batch con il modello Tabelle AutoML. 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 l'interfaccia a riga di comando di Google Cloud.

  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