Questo documento descrive un esempio di pipeline implementata in Google Cloud che esegue modelli di propensione. È destinato ai dati tecnici, machine learning engineer o team di marketing science che creano ed eseguire il deployment dei modelli di machine learning. Il documento presuppone che tu conosca le tecnologie concetti di apprendimento e che hai familiarità con Google Cloud, blocchi note BigQuery, Vertex AI Pipelines, Python e Jupyter. Inoltre, presuppone che tu abbia una buona conoscenza di Google Analytics 4 e la funzionalità di esportazione dei dati non elaborati in BigQuery.
La pipeline che utilizzi utilizza dati di esempio di Google Analytics. La crea diversi modelli utilizzando BigQuery ML e XGBoost e di eseguire la pipeline usando Vertex AI Pipelines. Questo descrive i processi di addestramento dei modelli, la loro valutazione, e il loro deployment. Descrive inoltre come automatizzare l'intero processo.
Il codice completo della pipeline si trova in un blocco note Jupyter in un Repository GitHub.
Che cos'è il modello di propensione?
La definizione del modello di propensione prevede le azioni che un consumatore potrebbe intraprendere. Esempi di i modelli di propensione includono la previsione di quali consumatori sono propensi ad acquistare un di registrarsi a un servizio o persino di abbandonare senza essere un cliente attivo di un brand.
L'output di un modello di propensione è un punteggio compreso tra 0 e 1 per ciascun consumatore, in cui questo punteggio rappresenta la probabilità che il consumatore intraprenda quell'azione. Uno. dei fattori chiave che spingono le organizzazioni verso un modello di propensione è la necessità per sfruttare al meglio i dati proprietari. Per i casi d'uso del marketing, la migliore propensione includono indicatori provenienti sia da fonti online che offline, come analisi e dati CRM.
Questa demo utilizza dati di esempio di GA4 in BigQuery. Per nel caso d'uso, potresti prendere in considerazione altri indicatori offline.
In che modo 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 terminato un modello, il team di software engineering deve includerlo nel codice per la produzione utilizzando un modello di machine learning come Fiocco o FastAPI. Questo processo spesso richiede che il modello sia creato in un nuovo framework, che i dati devono essere trasformati nuovamente. Questo lavoro può richiedere settimane o mesi, e molti modelli non passano in produzione.
Le operazioni di machine learning (MLOps) sono diventate importanti per ottenere valore progetti ML e MLOps, ed è ora una serie di competenze in evoluzione per la data science le tue organizzazioni. Per aiutare le organizzazioni a comprendere questo valore, Google Cloud ha pubblicato una Practitioners Guide to MLOps che fornisce una panoramica di MLOps.
Utilizzando i principi MLOps e Google Cloud, puoi eseguire il push dei modelli a un utilizzando un processo automatico che rimuove gran parte della complessità del processo manuale. Gli strumenti e la procedura descritti in questo documento discutere di un approccio alla gestione end-to-end della tua pipeline, che ti aiuta mettere i modelli in produzione. Il documento della guida per i professionisti menzionato in precedenza fornisce una soluzione orizzontale e un'idea di ciò che è possibile fare utilizzando MLOps e Google Cloud.
Che cos'è Vertex AI Pipelines?
Vertex AI Pipelines consente di eseguire pipeline ML create utilizzando l'SDK 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 gestione dei tuoi cluster Kubernetes. Vertex AI Pipelines affronta questa sfida. Poiché si tratta di un servizio gestito esegue lo scale up o lo scale down a seconda delle esigenze e non richiede manutenzione.
Ogni passaggio del processo Vertex AI Pipelines è costituito da un container indipendente che può assumere input o generare 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 nel 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 eventuali dipendenze.
Il processo di compilazione della pipeline
L'esempio descritto in questo documento utilizza un blocco note Jupyter per creare componenti della pipeline e di compilarli, eseguirli e automatizzarli. Come osservato in precedenza, il blocco note è in un repository GitHub.
Puoi eseguire il codice del blocco note utilizzando un Vertex AI Workbench blocchi note gestiti dall'utente, che gestisce l'autenticazione per te. Vertex AI Workbench consente puoi lavorare con i blocchi note per creare macchine, a Git. (Vertex AI Workbench include molti altre funzionalità, ma queste non sono trattate in questo documento.
Al termine dell'esecuzione della pipeline, viene visualizzato un diagramma simile al seguente generate in Vertex AI Pipelines:
Il diagramma precedente è un grafo diretto aciclico (DAG). La creazione e la revisione del DAG è il passaggio centrale per comprendere i dati o la pipeline ML. La chiave dei DAG sono che i componenti scorrono in un'unica direzione (in questo caso, dall'alto verso il basso) e che non si verifichi alcun ciclo, ovvero non si basa sul suo componente figlio. Alcuni componenti possono verificarsi in in parallelo, mentre altre hanno dipendenze e perciò si verificano in serie.
La casella di controllo verde in ogni componente indica che il codice è stato eseguito correttamente. Se errori, vedrai un punto esclamativo rosso. Puoi fare clic su ciascun nel diagramma per visualizzare ulteriori dettagli del job.
Il diagramma DAG è incluso in questa sezione del documento come progetto per ogni componente creato dalla pipeline. Il seguente elenco fornisce una descrizione di ogni componente.
La pipeline completa esegue i seguenti passaggi, come mostrato nel diagramma DAG:
create-input-view: questo componente crea un'istanza di BigQuery vista. Il componente copia l'SQL da un bucket Cloud Storage e lo compila parametri forniti dall'utente. Questa vista BigQuery è set di dati di input che viene utilizzato per tutti i modelli più avanti nella pipeline.build-bqml-logistic: la pipeline utilizza BigQuery ML per per creare un modello di regressione logistica. Al completamento, viene eseguita una nuova è visibile nella console BigQuery. Puoi utilizzare questo per visualizzare le prestazioni del modello e in seguito per creare previsioni.evaluate-bqml-logistic: la pipeline utilizza questo componente per creare un'istanza curva di precisione-richiamo (logistic_data_pathnel diagramma DAG) per il regressione logistica. Questo artefatto è archiviato in Cloud Storage di sincronizzare la directory di una VM con un bucket.build-bqml-xgboost: questo componente crea un modello XGBoost utilizzando in BigQuery ML. Una volta completato il componente, puoi visualizzare nuovo oggetto modello (system.Model) nella console BigQuery. Puoi utilizzare questo oggetto per visualizzare le prestazioni del modello e, in seguito, per creare per le previsioni.evaluate-bqml-xgboost: questo componente crea una curva di precisione-richiamo denominatoxgboost_data_pathper il modello XGBoost. Questo artefatto è archiviato in in un bucket Cloud Storage.build-xgb-xgboost: la pipeline crea un modello XGBoost. Questo utilizza Python al posto di BigQuery ML per consentirti diversi approcci alla creazione del modello. Quando questo componente viene completata, archivia un oggetto del modello e le metriche nel bucket Cloud Storage.deploy-xgb: questo componente esegue il deployment del modello XGBoost. Crea che consenta previsioni batch o online. Puoi esplorare l'endpoint nella scheda Modelli della console Vertex AI . L'endpoint scala automaticamente per corrispondere al traffico.build-bqml-automl: la pipeline crea un modello AutoML utilizzando BigQuery ML. Una volta completato il componente, un nuovo oggetto modello è visibile nella console BigQuery. Puoi utilizzare questo oggetto per visualizzare le prestazioni del modello e, in seguito, per per creare previsioni.evaluate-bqml-automl: la pipeline crea una curva di precisione-richiamo per il modello AutoML. L'artefatto è archiviato in nel bucket Cloud Storage.
Nota che il processo non esegue il push dei modelli BigQuery ML a endpoint. Questo perché è possibile generare previsioni direttamente dal modello presente in BigQuery. Se decidi tra utilizzare BigQuery ML e l'utilizzo di altre librerie per la tua soluzione, considera come generare le previsioni. Se una previsione batch giornaliera soddisfa e le tue esigenze, rimanere nell'ambiente BigQuery può semplificare nel tuo flusso di lavoro. Tuttavia, se hai bisogno di previsioni in tempo reale o se il tuo scenario necessita di funzionalità che si trovano in un'altra libreria, quindi segui i passaggi in questa documento per eseguire il push del modello salvato a un endpoint.
Costi
In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:
Per generare una stima dei costi basata sull'utilizzo previsto,
utilizza il Calcolatore prezzi.
Prima di iniziare
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
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 costruzione della pipeline sono integrate in una un blocco note che si trova Repository GitHub.
Per eseguire le attività, recupera il blocco note ed esegui le celle di codice il blocco note in ordine. Il flusso descritto in questo documento presuppone che tu dei blocchi note in Vertex AI Workbench.
Apri l'ambiente Vertex AI Workbench
Per iniziare, clona il repository GitHub in una Vertex AI Workbench.
- Nella console Google Cloud, seleziona il progetto in cui vuoi per creare il blocco note.
Vai alla pagina di Vertex AI Workbench.
Nella scheda Blocchi note gestiti dall'utente, fai clic su Nuovo blocco note.
Scegli un blocco note Python 3 nell'elenco dei tipi di blocco note.
Nella finestra di dialogo Nuovo blocco note, fai clic su Opzioni avanzate, quindi In Tipo di macchina, seleziona il tipo di macchina che vuoi utilizzare. Se Non sei sicuro, 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 e fai clic su Apri Jupyterlab.
L'ambiente JupyterLab si aprirà nel browser.
Per aprire una scheda Terminale, seleziona File > Nuovo > Avvio app.
Fai clic sull'icona Terminale nella scheda Avvio app.
Nel terminale, clona
mlops-on-gcpRepository GitHub:git clone https://github.com/GoogleCloudPlatform/cloud-for-marketing/
Al termine del comando, vedrai la cartella
cloud-for-marketingnell' browser di file.
Configura le impostazioni dei blocchi note
Prima di eseguire il blocco note, devi configurarlo. Il blocco note richiede del bucket Cloud Storage per archiviare gli artefatti della pipeline, la creazione del bucket.
- Crea un bucket Cloud Storage in cui il blocco note può archiviare gli artefatti della pipeline. Il nome del bucket devono essere univoci a livello globale.
- Nella
cloud-for-marketing/marketing-analytics/predicting/kfp_pipeline/cartella, apri il blocco notePropensity_Pipeline.ipynb. - Nel blocco note, imposta il valore della variabile
PROJECT_IDsull'ID di il 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: per comprendere il funzionamento della pipeline. Per l'implementazione completa, consulta Repository GitHub.
Crea la vista BigQuery
Il primo passaggio nella pipeline genera i dati di input, che verranno utilizzati per creare ciascun modello. Questo componente di Vertex AI Pipelines genera Vista BigQuery. Per semplificare il processo di creazione della vista, SQL è già stato generato e salvato in un file di testo in GitHub.
Il codice per ogni componente inizia con la decorazione (modificando una classe principale o
mediante attributi) la classe dei componenti Vertex AI Pipelines. Il codice
definisce poi la funzione create_input_view, che è un passaggio della pipeline.
La funzione richiede diversi input. Alcuni di questi valori sono attualmente
hardcoded nel codice, ad esempio la data di inizio e la data di fine. Quando automatizza
nella tua pipeline, puoi modificare il codice in modo da utilizzare valori adatti (ad esempio,
utilizzando
CURRENT_DATE
funzione per una data) oppure aggiornare il componente in modo che assuma questi valori come
invece di mantenerli hard-coded. Devi modificare anche il valore
di ga_data_ref al nome della tabella GA4 e imposta il valore del parametro
conversion alla conversione. (Questo esempio utilizza il GA4 pubblico
dati di esempio).
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 di ML di BigQuery
Dopo aver creato la vista, esegui il componente denominato build_bqml_logistic per
per creare un modello BigQuery ML. Questo blocco del blocco note è un nucleo
di strumento di authoring. Tramite la vista di addestramento che hai creato nel primo blocco,
crea un modello BigQuery ML. In questo esempio, il blocco note utilizza
regressione logistica.
Per informazioni sui tipi di modello e sugli iperparametri disponibili, consulta documentazione di riferimento di BigQuery ML.
Il seguente elenco 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 in BigQuery ML. La sezione successiva dei blocchi note mostra come usare direttamente XGBoost in Python invece di 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 viene quindi salvato
il modello come artefatto nel bucket Cloud Storage che hai creato.
La funzione supporta parametri aggiuntivi (metrics e model) per l'output
artefatti; sono richiesti da Vertex AI 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
XGBoost dalla sezione precedente. Il componente prende la precedente
L'artefatto del modello XGBoost crea un container, quindi esegue il deployment dell'endpoint,
fornendo anche l'URL dell'endpoint come artefatto, in modo da poterlo visualizzare. Quando
completato questo passaggio, è stato creato un endpoint Vertex AI
puoi visualizzare l'endpoint 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 che hai creato in precedenza. Puoi quindi specificare l'ordine degli elementi della pipeline se non vengono richiamate esplicitamente nel componente.
Ad esempio, il seguente codice nel blocco note definisce una pipeline. In questo
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 codice seguente nel blocco note imposta il valore enable_caching su true in
per abilitare la memorizzazione nella cache. Quando la memorizzazione nella cache è abilitata, qualsiasi esecuzione precedente in cui
completato correttamente non verrà eseguito di nuovo. Questo flag è utile
soprattutto quando si testa la pipeline, perché quando è abilitata la memorizzazione nella cache,
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 Vertex AI Pipelines nella console per vedere lo stato di questo job. Puoi guardare i video viene creato ed eseguito. Puoi anche monitorare gli errori per componenti specifici in in questa sezione facendo clic su ciascun elemento.
Per pianificare la pipeline, crea una Cloud Function e utilizza un 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 nello snippet di codice riportato di seguito:
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 completa in produzione
La pipeline completata ha eseguito le seguenti attività:
- È stato creato un set di dati di input.
- Addestramento di diversi modelli utilizzando sia BigQuery ML che XGBoost di Python.
- Risultati del modello analizzato.
- Deployment del modello XGBoost.
Hai anche automatizzato la pipeline utilizzando Cloud Functions e Cloud Scheduler vengono eseguiti ogni giorno.
La pipeline definita nel blocco note è stata creata per illustrare i modi per per creare vari modelli. Non eseguiresti la pipeline poiché è attualmente creata uno scenario di produzione. Tuttavia, puoi utilizzare questa pipeline come guida e modificare i componenti in base alle tue esigenze. Ad esempio, puoi modificare di creazione di caratteristiche al fine di sfruttare i dati, modificare gli intervalli di date e e magari per creare modelli alternativi. Dovreste anche scegliere il modello tra quelli che meglio soddisfano le tue esigenze di produzione.
Quando la pipeline è pronta per la produzione, puoi implementare attività di machine learning. Ad esempio, potresti implementare un modello campione/challenger, in cui ogni giorno in cui viene creato un nuovo modello e sia il nuovo modello (lo challenger) quella esistente (il campione) viene valutata in base a nuovi dati. Metti il nuovo modello produzione solo se le sue prestazioni sono migliori di quelle dell'attuale modello un modello di machine learning. Per monitorare l'avanzamento del sistema, potresti anche prendere nota di ogni le prestazioni del modello di giorno e visualizzare le tendenze nelle tendenze.
Esegui la pulizia
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.
Passaggi successivi
- Per scoprire come utilizzare MLOps per creare sistemi ML pronti per la produzione, consulta Guida alle MLOps per professionisti.
- Per saperne di più su Vertex AI, consulta Documentazione di Vertex AI.
- Per saperne di più su Kubeflow Pipelines, consulta documentazione di KFP.
- Per informazioni su TensorFlow Extended, consulta la guida dell'utente di TFX.
- Per altre architetture di riferimento, diagrammi e best practice, esplora il Centro architetture cloud.
Collaboratori
Autore: Tai Conley | Cloud Customer Engineer
Altro collaboratore: Lars Ahlfors | Cloud Customer Engineer