Questo documento descrive un esempio di pipeline implementata in Google Cloud che esegue modelli di propensione. È destinato a data engineer, machine learning engineer o team di marketing science che creano ed eseguono il deployment di modelli di machine learning. Il documento presuppone che tu conosca i concetti di machine learning e abbia familiarità con i blocchi note di Google Cloud, BigQuery, Kubeflow Pipelines, Python e Jupyter. Inoltre, presuppone 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, mentre tu esegui la pipeline utilizzando Kubeflow Pipelines su Vertex AI Pipelines. Questo documento descrive i processi di addestramento, valutazione e deployment dei modelli. Viene inoltre descritto come automatizzare l'intero processo.
Il codice completo della pipeline si trova in un blocco note Jupyter in un repository GitHub.
Che cos'è la creazione di modelli di propensione?
La modellazione della propensione prevede le azioni che un consumatore potrebbe intraprendere. Esempi di modelli di propensione includono la previsione di quali consumatori potrebbero acquistare un prodotto, registrarsi a un servizio o persino abbandonare e non essere più un cliente attivo di 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 intraprenda l'azione. Uno dei fattori chiave che spinge le organizzazioni alla creazione di modelli di propensione è la necessità di utilizzare al meglio i dati proprietari. Per i casi d'uso di marketing, i migliori modelli di propensione includeno indicatori sia da fonti online che offline, come l'analisi del sito e i dati CRM.
Questa demo utilizza dati di esempio GA360 in BigQuery. Per il tuo caso d'uso, ti consigliamo di prendere in considerazione altri indicatori offline.
Come MLOps semplifica le pipeline ML
La maggior parte dei modelli ML non viene utilizzata in produzione. I risultati del modello generano insight e spesso, dopo che i team di data science hanno completato un modello, un team di ML engineering o software engineering deve includerlo nel codice per la produzione utilizzando un framework come Flask o FastAPI. Questo processo spesso richiede che il modello venga creato in un nuovo framework, il che significa che i dati devono essere trasformati nuovamente. Questo lavoro può richiedere settimane o mesi e molti modelli non arrivano in produzione.
Le operazioni di machine learning (MLOps) sono diventate importanti per ottenere valore dai progetti ML e da MLOps e ora rappresentano un insieme di competenze in continua evoluzione per le organizzazioni di data science. Per aiutare le organizzazioni a comprendere questo valore, Google Cloud ha pubblicato una guida alle MLOps per i professionisti che fornisce una panoramica di MLOps.
Utilizzando i principi MLOps e Google Cloud, puoi eseguire il push dei modelli in un endpoint utilizzando un processo automatico che elimina gran parte della complessità del processo manuale. Gli strumenti e i processi descritti in questo documento illustrano un approccio alla proprietà end-to-end della pipeline, che ti consente di portare i modelli in produzione. Il documento della guida per professionisti menzionato in precedenza fornisce una soluzione orizzontale e una panoramica di ciò che è possibile ottenere utilizzando MLOps e Google Cloud.
Che cos'è Kubeflow Pipelines e che cos'è Vertex AI?
Kubeflow Pipelines è un framework open source che puoi utilizzare per creare la tua pipeline.
Ogni passaggio del processo di pipeline di Kubeflow è costituito da un container indipendente in grado di acquisire input o produrre output sotto forma di artefatti. Ad esempio, se un passaggio del processo crea il 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 delle eventuali 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 cluster Kubernetes. Vertex AI Pipelines affronta questa sfida. Poiché è un servizio gestito, esegue lo scale up o lo scale down in base alle esigenze 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 della pipeline e per compilarli, eseguirli e automatizzarli. Come indicato in precedenza, il blocco note si trova in un repository GitHub.
Puoi eseguire il codice del blocco note utilizzando Vertex AI Workbench, che gestisce l'autenticazione per te. Vertex AI Workbench consente di lavorare con i blocchi note per creare macchine, creare blocchi note e connettersi 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:
Il diagramma precedente è un grafo diretto aciclico (DAG). Creare ed esaminare i DAG è un passaggio centrale per comprendere i dati o la pipeline ML. Gli attributi chiave dei DAG prevedono che i componenti svolgano in un'unica direzione (in questo caso, dall'alto verso il basso) e che non si verifichi alcun ciclo, ovvero un componente principale non fa affidamento sul proprio componente figlio. Alcuni componenti possono verificarsi in parallelo, mentre altri hanno dipendenze e pertanto si presentano in serie.
La casella di controllo verde in ogni componente indica che il codice è stato eseguito correttamente. In caso di errori, viene visualizzato un punto esclamativo rosso. Puoi fare clic su ciascun componente del diagramma per visualizzare ulteriori dettagli sul job.
Il diagramma DAG è incluso in questa sezione del documento per fungere da progetto per ogni componente creato dalla pipeline. Il seguente elenco fornisce una descrizione di ciascun componente.
La pipeline completa esegue i seguenti passaggi, come mostrato nel diagramma DAG:
create-input-view: questo componente crea una vista BigQuery. Il componente copia SQL da un bucket Cloud Storage e compila i valori dei parametri forniti. Questa vista BigQuery è il set di dati di input utilizzato per tutti i modelli nelle fasi successive della pipeline.build-bqml-logistic: la pipeline usa BigQuery ML per creare un modello di regressione logistica. Al termine, un nuovo modello è visibile nella console BigQuery. Puoi utilizzare questo oggetto modello per visualizzare le prestazioni del modello e in seguito per creare previsioni.evaluate-bqml-logistic: la pipeline utilizza questo componente per creare una curva di precisione/richiamo (logistic_data_pathnel diagramma DAG) per la regressione logistica. Questo artefatto è archiviato in un bucket Cloud Storage.build-bqml-xgboost: questo componente crea un modello XGBoost utilizzando BigQuery ML. Una volta completato questo componente, puoi visualizzare un nuovo oggetto del modello (system.Model) nella console BigQuery. Puoi utilizzare questo oggetto per visualizzare le prestazioni del modello e in seguito per creare previsioni.evaluate-bqml-xgboost: questo componente crea una curva di precisione/richiamo denominataxgboost_data_pathper il modello XGBoost. L'artefatto è archiviato in un bucket Cloud Storage.build-xgb-xgboost: la pipeline crea un modello XGBoost. Questo componente utilizza Python anziché BigQuery ML per consentirti di visualizzare diversi approcci alla creazione del modello. Quando questo componente viene completato, archivia un oggetto del modello e le metriche relative alle prestazioni in un bucket Cloud Storage.deploy-xgb: questo componente esegue il deployment del modello XGBoost. Crea un endpoint che consente previsioni batch o online. Puoi esplorare l'endpoint nella scheda Modelli nella pagina della console Vertex AI. L'endpoint scala automaticamente in base al traffico.build-bqml-automl: la pipeline crea un modello AutoML utilizzando BigQuery ML. Al termine, un nuovo oggetto modello è visibile nella console BigQuery. Puoi utilizzare questo oggetto per visualizzare le prestazioni del modello e in seguito per creare previsioni.evaluate-bqml-automl: la pipeline crea una curva di precisione/richiamo per il modello AutoML. L'artefatto viene 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 tra utilizzare BigQuery ML e altre librerie per la tua soluzione, considera come devono essere generate le previsioni. Se una previsione batch giornaliera soddisfa le tue esigenze, rimanere nell'ambiente BigQuery può semplificare il tuo flusso di lavoro. Tuttavia, se hai bisogno di previsioni in tempo reale o se il tuo scenario ha bisogno di una funzionalità che si trova in un'altra libreria, segui i passaggi in questo documento per eseguire il push del modello salvato in un endpoint.
Costi
In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:
Per generare una stima dei costi in base all'utilizzo previsto,
utilizza il Calcolatore prezzi.
Prima di iniziare
- 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.
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
Il blocco note Jupyter per questo scenario
Le attività per la creazione e la creazione della pipeline sono integrate in un blocco note Jupyter in un repository GitHub.
Per eseguire le attività, ottieni il blocco note ed esegui le celle di codice al suo interno in ordine. Il flusso descritto in questo documento presuppone che esegui 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.
- Nella console Google Cloud, seleziona il progetto in cui vuoi creare il blocco note.
Vai alla pagina di Vertex AI Workbench.
Nella scheda Blocchi note gestiti dall'utente, fai clic su Nuovo blocco note.
Nell'elenco dei tipi di blocco note, scegli un blocco note Python 3.
Nella finestra di dialogo Nuovo blocco note, fai clic su Opzioni avanzate e, in Tipo di macchina, seleziona il tipo di macchina che vuoi utilizzare. In caso di dubbi, scegli n1-standard-1 (1 cVPU, 3,75 GB di RAM).
Fai clic su Crea.
La creazione dell'ambiente del blocco note richiede alcuni istanti.
Una volta creato il blocco note, selezionalo, quindi fai clic su Apri Jupyterlab.
L'ambiente JupyterLab si apre nel browser.
Per aprire una scheda Terminale, seleziona File > Nuovo > Avvio app.
Fai clic sull'icona Terminale nella scheda Avvio app.
Nel terminale, clona il repository GitHub
mlops-on-gcp:git clone https://github.com/GoogleCloudPlatform/cloud-for-marketing/
Al termine del comando, vedi la cartella
cloud-for-marketingnel browser di 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 inizia creando il bucket.
- Crea un bucket Cloud Storage in cui il blocco note possa archiviare gli artefatti della pipeline. Il nome del bucket deve essere univoco a livello globale.
- Nella cartella
cloud-for-marketing/marketing-analytics/predicting/kfp_pipeline/, apri il blocco notePropensity_Pipeline.ipynb. - Nel blocco note, imposta il valore della variabile
PROJECT_IDsull'ID del progetto Google Cloud in cui vuoi eseguire la pipeline. - Imposta il valore della variabile
BUCKET_NAMEsul nome del bucket appena creato.
La parte restante di questo documento descrive gli snippet di codice importanti per comprendere come funziona la pipeline. Per l'implementazione completa, consulta il repository di GitHub.
Creare la vista BigQuery
Il primo passaggio della pipeline genera i dati di input, che verranno utilizzati per creare ciascun modello. Questo componente Kubeflow Pipelines genera una vista 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 con la decoazione (modificando una classe o una funzione padre tramite attributi) della 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 quella di fine. Quando automatizzi la pipeline, puoi modificare il codice per utilizzare valori adatti (ad esempio, utilizzando la funzione CURRENT_DATE per una data) oppure aggiornare il componente in modo che utilizzi questi valori come parametri anziché mantenerli hardcoded. Devi anche modificare il valore di ga_data_ref nel nome della tabella GA360 e impostare il valore della variabile conversion sulla conversione. In questo esempio vengono utilizzati i dati
di esempio pubblici di GA360.
Il seguente elenco 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)
Creare 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
di base. Utilizzando la vista di addestramento creata
nel primo blocco, crea un modello BigQuery ML. In questo esempio, il blocco note utilizza
la regressione logistica.
Per informazioni sui tipi di modello e sugli iperparametri disponibili, consulta la documentazione di riferimento di BigQuery ML.
L'elenco seguente 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 prossima sezione dei blocchi note mostra come usare XGBoost direttamente in Python, anziché BigQuery ML.
Esegui il componente denominato build_bqml_xgboost per crearlo in modo da eseguire un modello di classificazione XGBoost standard con una ricerca a griglia. Il codice salva quindi 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 richiesti da 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 denominato deploy_xgb per creare un endpoint utilizzando il modello XGBoost della sezione precedente. Il componente prende l'artefatto del modello XGBoost precedente, crea un container, quindi esegue il deployment dell'endpoint, fornendo al contempo l'URL dell'endpoint come artefatto per consentirti di 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 specificare l'ordine degli elementi della pipeline se non vengono chiamati esplicitamente nel componente.
Ad esempio, il seguente codice nel blocco note definisce una pipeline. In questo caso, il codice richiede che il componente build_bqml_logistic_op venga eseguito 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. Quando la memorizzazione nella cache è abilitata, le esecuzioni precedenti in cui un componente è stato completato
non vengono eseguite nuovamente. Questo flag è utile soprattutto quando stai testando la pipeline perché, quando la memorizzazione nella cache è abilitata, l'esecuzione viene completata più velocemente 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 osservare durante la creazione e l'esecuzione di ogni container. Puoi anche monitorare gli errori di componenti specifici in questa sezione facendo clic su ciascuno di essi.
Per pianificare la pipeline, crea una Cloud Function e utilizza uno scheduler 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
)
Utilizza la pipeline completata in produzione
La pipeline completata ha eseguito le seguenti attività:
- È stato creato un set di dati di input.
- Abbiamo addestrato diversi modelli usando sia BigQuery ML che XGBoost di Python.
- Risultati del modello analizzato.
- Deployment del modello XGBoost.
Hai anche automatizzato la pipeline usando Cloud Functions e Cloud Scheduler per l'esecuzione giornaliera.
La pipeline definita nel blocco note è stata creata per illustrare il modo per creare vari modelli. Non eseguiresti la pipeline perché è 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 di caratteristiche per utilizzare i tuoi dati, modificare gli intervalli di date e magari creare modelli alternativi. Puoi anche scegliere il modello tra quelli illustrati che meglio soddisfano i tuoi requisiti di produzione.
Quando la pipeline è pronta per la produzione, potresti implementare altre attività. Ad esempio, potresti implementare un modello campione/sfida in cui ogni giorno viene creato un nuovo modello e sia il nuovo modello (lo sfidante) sia quello esistente (il campione) vengono valutati sulla base di nuovi dati. Inserisci il nuovo modello in produzione solo se le sue prestazioni sono migliori di quelle del modello attuale. Per monitorare l'avanzamento del sistema, puoi anche tenere traccia delle prestazioni del modello di ogni giorno e visualizzare le tendenze di rendimento.
Passaggi successivi
- Per scoprire di più sull'utilizzo di MLOps per creare sistemi ML pronti per la produzione, consulta la Guida alle MLOps per i professionisti.
- Per saperne di più su Vertex AI, consulta la documentazione di Vertex AI.
- Per informazioni su Kubeflow Pipelines, consulta la documentazione di KFP.
- Per altre architetture di riferimento, diagrammi e best practice, esplora il Cloud Architecture Center.