Utilizza le pipeline Kubeflow per la modellazione della propensione su Google Cloud

Questo documento descrive un esempio di pipeline implementata in Google Cloud che esegue modelli di propensione. È destinato a data engineer, ingegneri del machine learning o team di scienze del marketing che creano ed eseguono il deployment di modelli di machine learning. Il documento presuppone che tu conosca i concetti di machine learning e che hai familiarità con i blocchi note Google Cloud, BigQuery, Kubeflow Pipelines, Python e Jupyter. Inoltre, presume che tu abbia una conoscenza di Google Analytics 360 e della funzionalità di esportazione non elaborata di BigQuery.

La pipeline con cui lavori utilizza i dati di esempio di Google Analytics. La pipeline crea diversi modelli utilizzando BigQuery ML e XGBoost ed esegui la pipeline utilizzando Kubeflow Pipelines su Vertex AI Pipelines. Questo documento descrive i processi di addestramento, valutazione e deployment dei modelli. Descrive inoltre come puoi automatizzare l'intero processo.

Il codice pipeline completo si trova in un blocco note Jupyter in un repository GitHub.

Cos'è la modellazione della propensione?

La definizione del modello di previsione prevede le azioni che un consumatore potrebbe intraprendere. Alcuni esempi di modellazione della propensione includono la previsione dei consumatori più propensi ad acquistare un prodotto, la registrazione a un servizio o persino l'abbandono e che non possono più essere clienti attivi per un brand.

L'output di un modello di propensione è un punteggio compreso tra 0 e 1 per ogni consumatore, dove questo punteggio rappresenta la probabilità che il consumatore esegua l'azione. Uno dei fattori chiave che spingono le organizzazioni alla definizione del modello di propensione è la necessità di sfruttare al meglio i dati proprietari. Per i casi d'uso di marketing, i modelli di propensione migliori includono gli indicatori provenienti sia da origini online che offline, come i dati di analisi del sito e CRM.

Questa demo utilizza i dati di esempio di GA360 disponibili in BigQuery. Nel tuo caso d'uso, puoi prendere in considerazione altri indicatori offline.

In che modo MLOps semplifica le pipeline ML

La maggior parte dei modelli di machine learning non è utilizzata in produzione. I risultati del modello generano insight e, spesso dopo che i team di data science completano un modello, un team di progettazione ML o software deve inserirlo nel codice per la produzione utilizzando un framework come Flask o FastAPI. Spesso questo processo richiede la creazione del modello in un nuovo framework, il che significa che i dati devono essere trasformati nuovamente. Questa operazione può richiedere settimane o mesi e, di conseguenza, molti modelli non sono disponibili per la produzione.

Le operazioni di machine learning (MLOps) sono diventate importanti per ottenere valore dai progetti ML e ora sono un insieme di competenze in evoluzione per le organizzazioni di data science. Per aiutare le organizzazioni a comprendere questo valore, Google Cloud ha pubblicato una Guida per esperti di MLOps che fornisce una panoramica di MLOps.

Utilizzando i principi MLOps e Google Cloud, puoi eseguire il push dei modelli a un endpoint utilizzando un processo automatico che rimuove gran parte della complessità del processo manuale. Gli strumenti e la procedura descritti in questo documento illustrano un approccio alla proprietà end-to-end della tua pipeline, che ti aiuta a mettere in produzione i tuoi modelli. Il documento guida dei professionisti indicato in precedenza fornisce una soluzione orizzontale e una panoramica di ciò che è possibile utilizzando MLOps e Google Cloud.

Che cos'è Kubeflow Pipelines e che cos'è Vertex AI?

Kubeflow Pipelines è un framework open source che utilizzi per creare la tua pipeline.

Ogni passaggio nel processo delle pipeline Kubeflow è costituito da un container indipendente che può assumere input o produrre output sotto forma di artefatti. Ad esempio, se durante un processo viene creato un set di dati, l'output è l'artefatto del set di dati. Questo artefatto del set di dati può essere utilizzato come input per il passaggio successivo. Poiché ogni componente è un container separato, devi fornire informazioni per ogni componente della pipeline, ad esempio il nome dell'immagine di base e un elenco di tutte le dipendenze.

Vertex AI Pipelines consente di eseguire pipeline create utilizzando Kubeflow Pipelines o TensorFlow Extended (TFX). Senza Vertex AI, l'esecuzione di uno di questi framework open source su larga scala richiede la configurazione e la manutenzione dei tuoi cluster Kubernetes. Vertex AI Pipelines risolve questa sfida. Poiché è un servizio gestito, esegue lo scale up o lo scale down secondo le necessità e non richiede una manutenzione continua.

Il processo di compilazione della pipeline

L'esempio descritto in questo documento utilizza un blocco note Juptyer per creare i componenti pipeline e per compilarli, eseguirli e automatizzarli. Come indicato in precedenza, il blocco note si trova in un repository GitHub.

Puoi eseguire il codice blocco note utilizzando Vertex AI Workbench, che gestisce automaticamente l'autenticazione. Vertex AI Workbench ti consente di lavorare con blocchi note per creare macchine, creare blocchi note e connetterti a Git. (Vertex AI Workbench include molte altre funzionalità, ma non sono trattate in questo documento).

Al termine dell'esecuzione della pipeline, in Vertex AI Pipelines viene generato un diagramma simile al seguente:

Un grafico aciclico diretto che mostra i componenti eseguiti dalla pipeline.

Il diagramma precedente è un grafico aciclico diretto (DAG). Creare ed esaminare il DAG è un passaggio centrale per la comprensione dei dati o della pipeline ML. Gli attributi chiave dei DAG sono che i componenti passano in una sola direzione (in questo caso, dall'alto verso il basso) e che non si verifica nessun ciclo, ovvero un componente principale non si basa sul suo componente secondario. Alcuni componenti possono verificarsi in parallelo, mentre altri hanno dipendenze e pertanto si verificano in serie.

La casella di controllo verde in ogni componente indica che il codice è stato eseguito correttamente. Se si sono verificati errori, viene visualizzato un punto esclamativo di colore rosso. Puoi fare clic su ogni componente nel diagramma per visualizzare ulteriori dettagli sul job.

Il diagramma DAG è incluso in questa sezione del documento e serve da modello per ogni componente creato dalla pipeline. L'elenco seguente fornisce una descrizione di ogni componente.

La pipeline completa esegue i seguenti passaggi, come mostrato nel diagramma DAG:

  1. create-input-view: questo componente crea una vista BigQuery. Il componente copia SQL da un bucket Cloud Storage e inserisce i valori parametro da te forniti. Questa vista BigQuery è il set di dati di input che viene utilizzato per tutti i modelli più avanti nella pipeline.
  2. build-bqml-logistic: la pipeline utilizza BigQuery ML per creare un modello di regressione logistica. Al termine di questo componente, potrai visualizzare un nuovo modello nella console BigQuery. Puoi utilizzare questo oggetto modello per visualizzare le prestazioni del modello e successivamente per creare previsioni.
  3. evaluate-bqml-logistic: la pipeline utilizza questo componente per creare una curva di precisione/richiamo (logistic_data_path nel diagramma DAG) per la regressione logistica. Questo artefatto è archiviato in un bucket Cloud Storage.
  4. build-bqml-xgboost: questo componente crea un modello XGBoost utilizzando BigQuery ML. Al termine di questo componente, puoi visualizzare un nuovo oggetto modello (system.Model) nella console BigQuery. Puoi utilizzare questo oggetto per visualizzare le prestazioni del modello e successivamente per creare previsioni.
  5. evaluate-bqml-xgboost: questo componente crea una curva di precisione/richiamo con nome xgboost_data_path per il modello XGBoost. Questo artefatto è archiviato in un bucket Cloud Storage.
  6. build-xgb-xgboost: la pipeline crea un modello XGBoost. Questo componente utilizza Python anziché BigQuery ML per consentirti di vedere diversi approcci alla creazione del modello. Al completamento, questo componente archivia un oggetto modello e le metriche sulle prestazioni in un bucket Cloud Storage.
  7. deploy-xgb: questo componente esegue il deployment del modello XGBoost. Viene creato un endpoint che consente le previsioni batch o online. Puoi esplorare l'endpoint nella scheda Modelli nella pagina della console di Vertex AI. L'endpoint scala automaticamente in base al traffico.
  8. build-bqml-automl: la pipeline crea un modello AutoML mediante BigQuery ML. Quando il componente è completato, un nuovo oggetto modello è visibile nella console BigQuery. Puoi utilizzare questo oggetto per visualizzare le prestazioni del modello e in seguito per creare previsioni.
  9. evaluate-bqml-automl: la pipeline crea una curva di precisione/richiamo per il modello AutoML. L'artefatto è archiviato in un bucket Cloud Storage.

Tieni presente che il processo non esegue il push dei modelli BigQuery ML a un endpoint. perché puoi generare previsioni direttamente dall'oggetto modello in BigQuery. Quando decidi di utilizzare BigQuery ML e le altre librerie per la tua soluzione, valuta come devono essere generate le previsioni. Se una previsione batch giornaliera soddisfa le tue esigenze, rimanere nell'ambiente BigQuery può semplificare il flusso di lavoro. Tuttavia, se hai bisogno di previsioni in tempo reale o se lo scenario richiede funzionalità che si trovano in un'altra libreria, segui i passaggi descritti in questo documento per eseguire il push del modello salvato a un endpoint.

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono beneficiare di una prova gratuita.

Prima di iniziare

  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. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  5. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

Il blocco note Jupyter per questo scenario

Le attività per creare e creare la pipeline sono integrate in un blocco note Jupyter in un repository GitHub.

Per eseguire le attività, ottieni il blocco note, quindi esegui le celle di codice nel blocco note in ordine. Il flusso descritto in questo documento presuppone che tu stia eseguendo i blocchi note in Vertex AI Workbench.

Apri l'ambiente Vertex AI Workbench

Per iniziare, clona il repository GitHub in un ambiente Vertex AI Workbench.

  1. Nella console, seleziona il progetto in cui vuoi creare il blocco note.
  2. Vai alla pagina di Vertex AI Workbench.

    Vai alla pagina Vertex AI Workbench

  3. Nella scheda Blocchi note gestiti dall'utente, fai clic su Nuovo blocco note.

  4. Scegli un blocco note Python 3 nell'elenco dei tipi di blocco note.

  5. Nella finestra di dialogo Nuovo blocco note, fai clic su Opzioni avanzate e seleziona il tipo di macchina da utilizzare in Tipo di macchina. Se hai dubbi, scegli n1-standard-1 (1 cVPU, 3,75 GB di RAM).

  6. Fai clic su Crea.

    La creazione dell'ambiente di blocco note richiede alcuni istanti.

  7. Quando il blocco note è stato creato, seleziona il blocco note, quindi fai clic su Apri Jupyterlab.

    L'ambiente JupyterLab si apre nel browser.

  8. Per avviare una scheda Terminale, seleziona File > Nuovo > Avvio app.

  9. Fai clic sull'icona Terminale nella scheda Avvio app.

  10. Nel terminale, clona il repository mlops-on-gcp GitHub:

    git clone https://github.com/GoogleCloudPlatform/cloud-for-marketing/
    

    Al termine del comando, vedrai la cartella cloud-for-marketing nel browser dei file.

Configura le impostazioni dei blocchi note

Prima di eseguire il blocco note, devi configurarlo. Il blocco note richiede un bucket Cloud Storage per archiviare gli artefatti della pipeline, quindi devi iniziare creando il bucket.

  1. Crea un bucket Cloud Storage in cui il blocco note può archiviare gli artefatti della pipeline. Il nome del bucket deve essere univoco a livello globale.
  2. Nella cartella cloud-for-marketing/marketing-analytics/predicting/kfp_pipeline/, apri il blocco note Propensity_Pipeline.ipynb.
  3. Nel blocco note, imposta il valore della variabile PROJECT_ID sull'ID del progetto cloud in cui vuoi eseguire la pipeline.
  4. Imposta il valore della variabile BUCKET_NAME sul nome del bucket appena creato.

Nella parte restante di questo documento vengono descritti gli snippet di codice importanti per comprendere il funzionamento della pipeline. Per l'implementazione completa, consulta il repository di GitHub.

Crea la vista BigQuery

Il primo passaggio della pipeline genera i dati di input, che verranno utilizzati per creare ciascun modello. Questo componente Pipeline di Kubeflow genera una visualizzazione BigQuery. Per semplificare il processo di creazione della vista, alcuni SQL sono già stati generati e salvati in un file di testo in GitHub.

Il codice di ogni componente inizia decodificando (modificando una classe o una funzione padre tramite attributi) la classe del componente Kubeflow Pipelines. Il codice definisce quindi la funzione create_input_view, che è un passaggio della pipeline.

La funzione richiede diversi input. Alcuni di questi valori sono attualmente hardcoded nel codice, come la data di inizio e la data di fine. Quando automatizzi la pipeline, puoi modificare il codice per utilizzare valori idonei (ad esempio, utilizzando la funzione CURRENT_DATE per una data) oppure puoi aggiornare il componente per considerare questi valori come parametri anziché mantenerli impostati come hardcoded. Devi inoltre modificare il valore di ga_data_ref con il nome della tabella GA360 e impostare il valore della variabile conversion sulla conversione. Questo esempio utilizza i dati pubblici di esempio GA360.

La seguente scheda mostra il codice per il componente create-input-view.

@component(
   # this component builds a BigQuery view, which will be the underlying source for model
   packages_to_install=["google-cloud-bigquery", "google-cloud-storage"],
   base_image="python:3.9",
   output_component_file="output_component/create_input_view.yaml",
)
def create_input_view(view_name: str,
                     data_set_id: str,
                     project_id: str,
                     bucket_name: str,
                     blob_path: str

):
   from google.cloud import bigquery
   from google.cloud import storage
   client = bigquery.Client(project=project_id)
   dataset = client.dataset(data_set_id)
   table_ref = dataset.table(view_name)
   ga_data_ref = 'bigquery-public-data.google_analytics_sample.ga_sessions_*'
   conversion = "hits.page.pageTitle like '%Shopping Cart%'"
   start_date = '20170101'
   end_date = '20170131'

def get_sql(bucket_name, blob_path):
       from google.cloud import storage
       storage_client = storage.Client()
       bucket = storage_client.get_bucket(bucket_name)
       blob = bucket.get_blob(blob_path)
       content = blob.download_as_string()
       return content
def if_tbl_exists(client, table_ref):

...

   else:
       content = get_sql()
       content = str(content, 'utf-8')
       create_base_feature_set_query = content.
                                   format(start_date = start_date,
                                   end_date = end_date,
                                   ga_data_ref = ga_data_ref,
                                   conversion = conversion)
shared_dataset_ref = client.dataset(data_set_id)
base_feature_set_view_ref = shared_dataset_ref.table(view_name)
base_feature_set_view = bigquery.Table(base_feature_set_view_ref)
base_feature_set_view.view_query = create_base_feature_set_query.format(project_id)
base_feature_set_view = client.create_table(base_feature_set_view)

Crea il modello BigQuery ML

Dopo aver creato la vista, esegui il componente denominato build_bqml_logistic per creare un modello BigQuery ML. Questo blocco del blocco note è un componente principale. Utilizzando la vista addestramento che hai creato nel primo blocco, viene creato un modello BigQuery ML. In questo esempio, il blocco note utilizza la regressione logistica.

Per informazioni sui tipi di modelli e sugli iperparametri disponibili, consulta la documentazione di riferimento di BigQuery ML.

La scheda che segue mostra il codice per questo componente.

@component(
   # this component builds a logistic regression with BigQuery ML
   packages_to_install=["google-cloud-bigquery"],
   base_image="python:3.9",
   output_component_file="output_component/create_bqml_model_logistic.yaml"
)
def build_bqml_logistic(project_id: str,
                       data_set_id: str,
                       model_name: str,
                       training_view: str
):
   from google.cloud import bigquery
   client = bigquery.Client(project=project_id)
   model_name = f"{project_id}.{data_set_id}.{model_name}"
   training_set = f"{project_id}.{data_set_id}.{training_view}"
   build_model_query_bqml_logistic = '''
   CREATE OR REPLACE MODEL `{model_name}`
   OPTIONS(model_type='logistic_reg'
   , INPUT_LABEL_COLS = ['label']
   , L1_REG = 1
   , DATA_SPLIT_METHOD = 'RANDOM'
   , DATA_SPLIT_EVAL_FRACTION = 0.20
   ) AS
       SELECT * EXCEPT (fullVisitorId, label),
       CASE WHEN label is null then 0 ELSE label end as label
   FROM `{training_set}`
   '''.format(model_name = model_name, training_set = training_set)
job_config = bigquery.QueryJobConfig()
client.query(build_model_query_bqml_logistic, job_config=job_config)

Usa XGBoost anziché BigQuery ML

Il componente illustrato nella sezione precedente utilizza BigQuery ML. La sezione successiva dei blocchi note mostra come utilizzare direttamente XGBoost in Python invece di BigQuery ML.

Esegui il componente build_bqml_xgboost per creare il componente in modo che esegua un modello di classificazione XGBoost standard con una ricerca a griglia. Il codice quindi salva il modello come artefatto nel bucket Cloud Storage che hai creato. La funzione supporta parametri aggiuntivi (metrics e model) per gli artefatti di output; questi parametri sono obbligatori per Kubeflow Pipelines.

@component(
   # this component builds an xgboost classifier with xgboost
   packages_to_install=["google-cloud-bigquery", "xgboost", "pandas", "sklearn", "joblib", "pyarrow"],
   base_image="python:3.9",
   output_component_file="output_component/create_xgb_model_xgboost.yaml"
)
def build_xgb_xgboost(project_id: str,
                     data_set_id: str,
                     training_view: str,
                     metrics: Output[Metrics],
                     model: Output[Model]
):

...

  data_set = f"{project_id}.{data_set_id}.{training_view}"
  build_df_for_xgboost = '''
                         SELECT * FROM `{data_set}`
                         '''.format(data_set = data_set)

...

  xgb_model = XGBClassifier(n_estimators=50,
                            objective='binary:hinge',
                            silent=True,
                            nthread=1,
                           eval_metric="auc")
   random_search = RandomizedSearchCV(xgb_model,
                                     param_distributions=params,
                                     n_iter=param_comb,
                                     scoring='precision',
                                     n_jobs=4,
                                     cv=skf.split(X_train,y_train),
                                     verbose=3,
                                     random_state=1001 )
  random_search.fit(X_train, y_train)
  xgb_model_best = random_search.best_estimator_
  predictions = xgb_model_best.predict(X_test)
  score = accuracy_score(y_test, predictions)
  auc = roc_auc_score(y_test, predictions)
  precision_recall = precision_recall_curve(y_test, predictions)

  metrics.log_metric("accuracy",(score * 100.0))
  metrics.log_metric("framework", "xgboost")
  metrics.log_metric("dataset_size", len(df))
  metrics.log_metric("AUC", auc)

  dump(xgb_model_best, model.path + ".joblib")

Crea un endpoint

Esegui il componente deploy_xgb per creare un endpoint utilizzando il modello XGBoost della sezione precedente. Il componente utilizza l'artefatto del modello XGBoost precedente, crea un container, quindi esegue il deployment dell'endpoint e fornisce l'URL dell'endpoint come elemento, in modo che tu possa visualizzarlo. Al termine di questo passaggio, è stato creato un endpoint Vertex AI e puoi visualizzarlo nella pagina della console per Vertex AI.

@component(
   # Deploys xgboost model
   packages_to_install=["google-cloud-aiplatform", "joblib", "sklearn", "xgboost"],
   base_image="python:3.9",
   output_component_file="output_component/xgboost_deploy_component.yaml",
)
def deploy_xgb(
   model: Input[Model],
   project_id: str,
   vertex_endpoint: Output[Artifact],
   vertex_model: Output[Model]
):
   from google.cloud import aiplatform
   aiplatform.init(project=project_id)
   deployed_model = aiplatform.Model.upload(
       display_name="tai-propensity-test-pipeline",
       artifact_uri = model.uri.replace("model", ""),
       serving_container_image_uri="us-docker.pkg.dev/vertex-ai/prediction/xgboost-cpu.1-4:latest"
   )
   endpoint = deployed_model.deploy(machine_type="n1-standard-4")
# Save data to the output params
   vertex_endpoint.uri = endpoint.resource_name
   vertex_model.uri = deployed_model.resource_name

Definisci la pipeline

Per definire la pipeline, definisci ogni operazione in base ai componenti creati in precedenza. Puoi quindi specificare l'ordine degli elementi della pipeline se non sono esplicitamente chiamati nel componente.

Ad esempio, il codice seguente nel blocco note definisce una pipeline. In questo caso, il codice richiede l'esecuzione del componente build_bqml_logistic_op dopo il componente create_input_view_op.

@dsl.pipeline(
   # Default pipeline root. You can override it when submitting the pipeline.
   pipeline_root=PIPELINE_ROOT,
   # A name for the pipeline.
   name="pipeline-test",
   description='Propensity BigQuery ML Test'
)
def pipeline():

   create_input_view_op = create_input_view(
                          view_name = VIEW_NAME,
                          data_set_id = DATA_SET_ID,
                          project_id = PROJECT_ID,
                          bucket_name = BUCKET_NAME,
                          blob_path = BLOB_PATH
                                            )
    build_bqml_logistic_op = build_bqml_logistic(
                        project_id = PROJECT_ID,
                        data_set_id = DATA_SET_ID,
                        model_name = 'bqml_logistic_model',
                        training_view = VIEW_NAME
                                                  )

 # several components have been deleted for brevity

   build_bqml_logistic_op.after(create_input_view_op)
   build_bqml_xgboost_op.after(create_input_view_op)
   build_bqml_automl_op.after(create_input_view_op)
   build_xgb_xgboost_op.after(create_input_view_op)

   evaluate_bqml_logistic_op.after(build_bqml_logistic_op)
   evaluate_bqml_xgboost_op.after(build_bqml_xgboost_op)
   evaluate_bqml_automl_op.after(build_bqml_automl_op)

Compila ed esegui la pipeline

Ora puoi compilare ed eseguire la pipeline.

Il seguente codice nel blocco note imposta il valore enable_caching su true per abilitare la memorizzazione nella cache. Se la memorizzazione nella cache è attiva, le esecuzioni precedenti in cui un componente è stato completato correttamente non potranno essere eseguite di nuovo. Questo flag è utile soprattutto quando stai testando la pipeline perché, quando la memorizzazione nella cache è abilitata, l'esecuzione viene completata più rapidamente e utilizza meno risorse.

compiler.Compiler().compile(
   pipeline_func=pipeline, package_path="pipeline.json"
)
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")
run = pipeline_jobs.PipelineJob(
   display_name="test-pipeine",
   template_path="pipeline.json",

   job_id="test-{0}".format(TIMESTAMP),
   enable_caching=True
)
run.run()

Automatizza la pipeline

In questa fase hai avviato la prima pipeline. Puoi controllare la pagina Vertex AI Pipelines nella console per vedere lo stato di questo job. Puoi guardarli man mano che ogni container viene creato ed eseguito. Puoi anche monitorare gli errori per componenti specifici in questa sezione facendo clic su ognuno di essi.

Per pianificare la pipeline, crei una funzione Cloud Functions e utilizzi uno scheduler in modo simile a un cron job.

Il codice nell'ultima sezione del blocco note pianifica l'esecuzione della pipeline una volta al giorno, come mostrato nel seguente snippet di codice:

from kfp.v2.google.client import AIPlatformClient
api_client = AIPlatformClient(project_id=PROJECT_ID,
                            region='us-central1'
                            )
api_client.create_schedule_from_job_spec(
   job_spec_path='pipeline.json',
   schedule='0 * * * *',
   enable_caching=False
)

Usa la pipeline terminata in produzione

La pipeline completata ha eseguito le seguenti attività:

  • È stato creato un set di dati di input.
  • Addestrato diversi modelli utilizzando sia BigQuery ML che XGBoost di Python.
  • Risultati del modello analizzato.
  • Deployment del modello XGBoost eseguito.

Hai anche automatizzato la pipeline utilizzando Cloud Functions e Cloud Scheduler per l'esecuzione giornaliera.

La pipeline definita nel blocco note è stata creata per illustrare i modi in cui creare vari modelli. Non eseguirai la pipeline in quanto è attualmente creata in uno scenario di produzione. Tuttavia, puoi utilizzare questa pipeline come guida e modificare i componenti in base alle tue esigenze. Ad esempio, puoi modificare il processo di creazione delle funzionalità per sfruttare i dati, cambiare gli intervalli di date e persino creare modelli alternativi. Tra le opzioni illustrate, sceglieresti anche il modello che meglio soddisfa i tuoi requisiti di produzione.

Quando la pipeline è pronta per la produzione, puoi implementare altre attività. Ad esempio, puoi implementare un modello "campione/challenger", dove ogni giorno viene creato un nuovo modello e vengono valutati nuovi dati sia il nuovo modello (lo sfidante) sia quello esistente (il campione). Puoi mettere in produzione il nuovo modello solo se le sue prestazioni sono migliori rispetto a quelle del modello attuale. Per monitorare l'avanzamento del sistema, puoi anche tenere traccia delle prestazioni del modello per ogni giorno e visualizzare le prestazioni del dispositivo.

Passaggi successivi