Vai al contenuto principale

Tutorial su Vertex AI: guida completa per principianti

Padroneggia le basi per configurare Vertex AI ed eseguire workflow di machine learning.
· 14 min leggi

Scopri con l'IA

Anche se la maggior parte delle persone associa Google ai motori di ricerca, l'azienda ha radici profonde anche nell'industria della data science. Continua a offrire prodotti e soluzioni all'avanguardia pensati per ottenere il massimo valore dai dati. Uno di questi prodotti, Vertex AI, è stato rilasciato nel 2021 per semplificare il processo di machine learning su scala enterprise.

In questo tutorial vedremo come iniziare a usare la piattaforma Vertex AI di Google e come utilizzarla per coprire un'ampia gamma di attività del ciclo di vita del ML. Concluderemo con un modello distribuito a cui potremo inviare richieste per generare previsioni per un compito di classificazione.

Che cos'è Vertex AI?

Un tipico ciclo di vita del machine learning comprende molte fasi:

  • Preparazione, ingestione, esplorazione dei dati
  • Feature engineering, selezione
  • Addestramento e tuning del modello
  • Distribuzione e monitoraggio del modello

Tutte queste fasi e sottofasi richiedono set di strumenti diversi e un team eterogeneo di esperti per coordinarle.

Vertex AI di Google Cloud semplifica e unifica l'intero processo in un'unica piattaforma.

Sebbene le applicazioni ML su larga scala richiedano specialisti esperti, Vertex AI mette in grado utenti di qualsiasi livello:

  • AutoML per principianti: Non richiede esperienza di coding. Ti basta fornire i dati e, con pochi clic, AutoML genera per te un modello di alta qualità. Tutto il lavoro pesante di preparazione dei dati e costruzione del modello, inclusa la selezione degli algoritmi e il tuning degli iperparametri, avviene dietro le quinte.
  • Addestramento di modelli personalizzati per esperti: Il limite è la tua esperienza. Per data scientist esperti e ML engineer, Vertex AI offre la flessibilità di addestrare modelli con i framework preferiti, come PyTorch, TensorFlow o XGBoost.
  • Distribuzione per tutti: Una volta che hai un modello addestrato, sia con AutoML sia personalizzato, Vertex AI rende la distribuzione semplicissima. Puoi pubblicare modelli come API in tempo reale da integrare nei tuoi prodotti o usare la predizione batch per compiti su larga scala.

Ci sono molte altre funzionalità che non menzioniamo qui: le proverai in prima persona nel corso del tutorial.

Cosa sono i servizi Google Cloud?

Homepage di Google Cloud Services

Prima di esplorare la piattaforma, occorre menzionare il suo “genitore”: i servizi Google Cloud. Google Cloud Services include un'ampia gamma di soluzioni di cloud computing che offrono storage, networking, database, analytics e funzionalità di machine learning.

Questi servizi lavorano in sinergia con Vertex AI per unificare il tuo workflow di machine learning. Ecco una panoramica dei servizi usati spesso con Vertex AI:

Archiviazione e gestione dei dati

  • Cloud Storage: Funziona come repository centrale per i dati grezzi, accessibile da Vertex AI per addestramento e analisi.
  • BigQuery: Un potente data warehouse per archiviare e interrogare grandi dataset, che consente a Vertex AI di usare BigQuery ML per l'addestramento integrato.

Risorse di calcolo

  • Compute Engine: Fornisce macchine virtuali con varie configurazioni per le esigenze di addestramento personalizzato. Vertex AI può collegarsi a queste macchine per compiti di training intensivi.
  • Vertex AI Pipelines: Coordina workflow ML complessi su varie risorse di calcolo per maggiore efficienza.

I servizi Google Cloud sono sempre disponibili dal tuo account Google visitando cloud.google.com. Se non li hai mai usati, clicca su “Get started for free” per ottenere la prova gratuita.

Altrimenti, puoi andare direttamente su console.cloud.google.com per iniziare.

Configurare la Google Cloud Console per Vertex AI

Disclaimer: Se vuoi seguire il tutorial passo dopo passo, preparati a spendere 25–30 $ su Vertex AI. Useremo le configurazioni più economiche.

Visitando la Google Cloud Console, con ogni probabilità atterrerai sulla seguente pagina di benvenuto:

Google Cloud Console per Vertex AI

Qui trovi il nome del tuo workspace; il mio è ibexprogramming.com.

La prima cosa da fare è creare un progetto. I progetti Google Cloud sono unità organizzative di alto livello per gestire le risorse legate a un'attività specifica. Ecco una GIF su come crearne uno:

Una GIF che mostra come creare un nuovo progetto nella Google Cloud Console

Una volta creato il progetto, selezionalo in modo che la barra superiore della pagina mostri questo:

La barra superiore della Google Cloud Console

Ora devi creare un account di fatturazione, perché Vertex AI richiede le informazioni di pagamento per abilitare i suoi servizi. Non preoccuparti: non ti verrà addebitato nulla finché non utilizzi risorse a pagamento. Quindi, vai su https://console.cloud.google.com/billing:

Uno screenshot di un account di fatturazione nella Google Cloud Console

Se non hai già un account come il mio, clicca su “Create account” e segui le istruzioni. Collegheremo questo account di fatturazione al nostro progetto nella prossima sezione.

Dopodiché, torna su https://console.cloud.google.com/ e clicca sul pulsante “View all products” in fondo alla pagina:

Un altro screenshot della Google Cloud Console

La pagina successiva elencherà tutti i servizi offerti da Google Cloud per il tuo progetto. Cerca “Vertex AI” (Ctrl + F) e fissalo nel menu per un accesso rapido. Poi clicca sul servizio stesso:

Un elenco di tutti i prodotti Google Cloud

Verrai indirizzato alla tua dashboard di Vertex AI. Potrebbe comparire una finestra che ti chiede di abilitare la Vertex AI API: scegli “Enable”. Se la finestra non compare, puoi cliccare sul pulsante “Enable all API permissions” per fare la stessa cosa.

Ora siamo pronti a caricare un dataset su Vertex AI.

Caricare un dataset in Vertex AI

Ci sono diversi modi per aggiungere un dataset a Vertex AI. In questa sezione useremo un file CSV locale per semplicità.

Scarica un dataset di esempio

Per l'articolo useremo il Dry Bean dataset dall'UCI Machine Learning Repository. Contiene 13.000 istanze di fagioli e le loro 15 misurazioni numeriche.

Il compito è classificarli in sette tipi di fagioli: Seker, Barbunya, Bombay, Cali, Dermosan, Horoz e Sira.

Dopo averlo scaricato, salva il file Excel all'interno dello ZIP scaricato nella tua directory locale:

from pathlib import Path

cwd = Path.cwd()
data_path = cwd / "data" / "Dry_Bean_Dataset.xlsx"

Poi possiamo leggere questo file con pandas e salvarlo in formato CSV:

import pandas as pd

beans = pd.read_excel(data_path)

beans.shape
(13611, 17)

Nota: la funzione read_excel richiede di installare la libreria openpyxl con PIP.

Ottimo, abbiamo il dataset come DataFrame. Salviamolo in CSV:

beans.to_csv(cwd / "data" / "dry_bean.csv", index=False)

Crea un bucket di Cloud Storage

Come detto prima, ci serve un bucket di Google Cloud Storage per archiviare i dati grezzi. Segui la GIF qui sotto per raggiungere la dashboard del prodotto:

Una GIF che mostra come collegare un account di fatturazione a un progetto Google Cloud

La GIF mostra che, per iniziare a usare i servizi di storage, dobbiamo collegare un account di fatturazione, utilizzando quello creato in precedenza. Poi potrai creare un bucket con un nome univoco a livello globale:

Una GIF che mostra come creare un bucket di Google Cloud Storage

Una volta trovato un nome univoco, clicca su “Continue” finché il bucket non viene creato: puoi lasciare le opzioni predefinite per tutti i campi.

Ora siamo pronti per inserire il file CSV salvato nella sezione precedente.

Inserire un CSV locale in Vertex AI

Torniamo alla dashboard di Vertex AI e apriamo la scheda Datasets:

Una GIF che mostra come passare alla scheda datasets della dashboard di Vertex AI

La troverai vuota, quindi clicca sul pulsante “+Create”:

Uno screenshot della scheda datasets di Vertex AI

Dai al dataset un nome univoco e scegli l'opzione tabular:

Una GIF che mostra come creare un nuovo dataset in Vertex AI

La piattaforma mostrerà quindi le opzioni di origine. Scegli di caricare un file CSV locale e, per il percorso Cloud Storage, seleziona il bucket appena creato:

Una GIF che mostra come inserire un CSV locale in un bucket di cloud storage esistente

Una volta caricato correttamente il dataset, ti verrà mostrata la scheda “Analyze”, che contiene metadati di base sul file CSV. Vedrai anche un pulsante “TRAIN NEW MODEL”, che avvia un job di training AutoML.

Tuttavia, non useremo quel pulsante perché è pensato per chi è alle primissime armi con il ML. Al contrario, utilizzeremo Vertex AI Workbench per configurare un ambiente di coding JupyterLab e le risorse di calcolo per eseguire sia AutoML sia librerie personalizzate.

Configurare JupyterLab e le risorse di calcolo in Vertex AI Workbench

Poiché Vertex AI è una piattaforma unificata, offre anche ambienti di sviluppo chiamati workbench. Per crearne uno, vai all'apposita scheda e segui le istruzioni nella GIF qui sotto:

Una GIF che mostra come creare un Vertex AI Workbench

Ogni workbench include JupyterLab 3 preinstallato. Quindi ti basta configurare l'hardware in base al budget e alle esigenze. Poiché abbiamo un dataset piuttosto piccolo, per l'illustrazione ho scelto l'istanza più debole, che costa solo ~0,12 $ l'ora (consiglio una macchina con più core CPU per velocizzare i calcoli).

Ho anche impostato l'arresto per inattività a 10 minuti, così l'ambiente si spegne automaticamente se mi dimentico di fermarlo.

Il workbench impiegherà un po' a inizializzarsi. Quando è pronto, compare il pulsante “OPEN JUPYTERLAB” e possiamo cliccarlo:

Uno screenshot dell'interfaccia di JupyterLab all'interno di un workbench Vertex AI

Verrai reindirizzato alla familiare interfaccia di JupyterLab. Da lì, crea un nuovo notebook Python 3 e rinominalo come preferisci. Nella prima cella, installa/aggiorna l'SDK dei servizi Google Cloud google-cloud-aiplatform:

!pip3 install --upgrade --quiet google-cloud-aiplatform

Poi puoi elencare i progetti disponibili sul tuo account con gcloud config list:

!gcloud config list
[compute]
region = us-central1
[core]
account = # HIDDEN #
disable_usage_reporting = True
project = vertexai-tutorial-423010
[dataproc]
region = us-central1

Your active configuration is: [default]

gcloud e gsutil sono utility da terminale disponibili in tutti i workbench. Consentono di gestire in modo efficiente i servizi Google Cloud.

Dall'output stampato, salva le seguenti informazioni come variabili Python:

PROJECT_ID = 'vertexai-tutorial-423010'
BUCKET_URI = 'gs://vetex-tutorial-bucket-bex'
REGION = 'us-central1'

Non dimenticare di cambiare BUCKET_URI con il nome del tuo bucket. Poi importa il sottomodulo aiplatform e inizializzalo:

from google.cloud import aiplatform as ai

ai.init(project=PROJECT_ID, location=REGION, staging_bucket=BUCKET_URI)

aiplatform fungerà da SDK per interagire con le funzionalità di Vertex AI.

Un'immagine che mostra l'elenco dei Vertex AI workbench disponibili.

Quando finisci di seguire il tutorial o fai una pausa, ricordati di STOPPARE l'istanza per evitare costi indesiderati.

Addestrare e distribuire modelli AutoML in Vertex AI

Ora addestriamo un modello con AutoML che, come detto, si occupa di tutto il lavoro pesante e restituisce il miglior modello che riesce ad addestrare per il dataset fornito. Questo significa che, per sfruttare appieno AutoML, devi assicurarti che il dataset fornito sia di qualità il più possibile. Vale quindi la pena dedicare del tempo a creare nuove feature ed eseguire eventuali passaggi di preprocessing in anticipo.

AutoML esegue il preprocessing del dataset internamente, ma non può correggere tutti i problemi dei tuoi dati.

In questa sezione, tuttavia, addestreremo solo un modello AutoML di base senza preprocessing o feature engineering, per semplicità.

Caricare i dati da un bucket di Google Storage

Per prima cosa vogliamo caricare il dataset CSV dal nostro bucket e dedicarci un po' di esplorazione. Ricorda, l' EDA è un passaggio importante: puoi approfondire nel nostro corso Exploratory Data Analysis in Python!

import pandas as pd

# Path to your CSV file in GCS bucket
gcs_path = "gs://vertex-tutorial-bucket-bex/dry_bean.csv"

beans = pd.read_csv(gcs_path)

beans.head()

Le prime cinque righe del dataset Dry Beans dall'UCI.

La buona notizia è che pandas può scaricare file da percorsi GCS. L'unico dettaglio è che il codice sopra funziona solo nei workbench Vertex AI, perché sono già autenticati con le tue credenziali Google Cloud.

Esplorare i dati con pandas in Vertex AI

Non eseguiremo un'analisi approfondita del dataset, per non allontanarci dal punto principale dell'articolo. Ci limiteremo quindi a stampare alcune statistiche riassuntive e grafici:

beans.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 13611 entries, 0 to 13610
Data columns (total 17 columns):
#   Column           Non-Null Count  Dtype 
---  ------           --------------  ----- 
0   Area             13611 non-null  int64 
1   Perimeter        13611 non-null  float64
2   MajorAxisLength  13611 non-null  float64
3   MinorAxisLength  13611 non-null  float64
4   AspectRation     13611 non-null  float64
5   Eccentricity     13611 non-null  float64
6   ConvexArea       13611 non-null  int64 
7   EquivDiameter    13611 non-null  float64
8   Extent           13611 non-null  float64
9   Solidity         13611 non-null  float64
10  roundness        13611 non-null  float64
11  Compactness      13611 non-null  float64
12  ShapeFactor1     13611 non-null  float64
13  ShapeFactor2     13611 non-null  float64
14  ShapeFactor3     13611 non-null  float64
15  ShapeFactor4     13611 non-null  float64
16  Class            13611 non-null  object
dtypes: float64(14), int64(2), object(1)
memory usage: 1.8+ MB

Abbiamo quindi 15 feature numeriche e una singola colonna target — Class. Ci sono ~13.000 record e nessun valore mancante. Questo semplificherà molto l'addestramento.

Salviamo i nomi delle feature in un elenco a parte, potrebbero servirci dopo:

feature_names = beans.columns.tolist()

Ora creiamo un pair-plot di alcune feature che sembrano importanti:

import seaborn as sns

sns.pairplot(
   beans,
   vars=["Area", "MajorAxisLength", "MinorAxisLength", "Eccentricity", "roundness"],
   hue="Class",
);

Un pairplot di alcune feature del dataset Dry Beans.

Notiamo alcuni trend interessanti: soprattutto, sembra che i fagioli Bombay (verde) siano chiaramente separati dagli altri in termini di misure fisiche.

Tracciamo anche una matrice di correlazione:

import matplotlib.pyplot as plt

correlation = beans.corr(numeric_only=True)

# Create a square heatmap with center at 0
sns.heatmap(correlation, center=0, square=True, cmap="coolwarm", vmin=-1, vmax=1)

plt.show()

Una matrice di correlazione per le feature numeriche del dataset Dry Beans

Abbiamo alcune feature quasi perfettamente correlate, il che ha senso dato che sono legate a misure fisiche. Tuttavia ci sono anche coppie di feature con correlazione nulla o molto bassa.

A questo punto lascio a te continuare l'esplorazione e provare a formulare alcune domande sul dataset.

Avviare un job di training AutoML

Per avviare un job di training AutoML, serve prima un oggetto dataset compatibile:

ds = ai.TabularDataset.create(
   display_name="dry_bean_dataset", gcs_source=gcs_path
)
TabularDataset created. 
type(ds)
google.cloud.aiplatform.datasets.tabular_dataset.TabularDataset
ds.resource_name
'projects/10783853768/locations/us-central1/datasets/4978116960081412096'

Usiamo il metodo TabularDataset.create per inizializzarlo come ds. Vertex AI gli assegna un nome interno, accessibile tramite l'attributo resource_name.

Ora inizializziamo il job con la classe ai.AutoMLTabularTrainingJob. Richiede due argomenti:

  • Un display name per il job
  • L'obiettivo del task — in questo caso, classificazione.
job = ai.AutoMLTabularTrainingJob(
   display_name="dry-bean-classification",
   optimization_prediction_type="classification",
)

Quindi eseguiamo il metodo run del job:

model = job.run(
   dataset=ds,
   target_column="Class",
   training_fraction_split=0.8,
   validation_fraction_split=0.1,
   test_fraction_split=0.1,
   model_display_name="baseline-classification-model",
   disable_early_stopping=False,
)

I parametri del metodo sono abbastanza autoesplicativi. Il codice impiegherà un po' a terminare (a seconda della potenza di calcolo).

Se vai nella scheda “MODEL DEVELOPMENT > TRAINING” della dashboard e clicchi sul nome del job, vedrai l'avanzamento in tempo reale. L'immagine sotto mostra lo stato di preprocessing:

Un job di training in corso su Vertex AI

Osservare i risultati

Una volta concluso l'addestramento, torna alla scheda di training e clicca sul nome del modello. Questa volta verranno elencate le metriche di performance del modello:

Una GIF che mostra le metriche per un modello addestrato in Vertex AI

Come puoi vedere, anche per un modello di base le metriche sono molto buone, tutte sopra 0,90.

Distribuire un modello AutoML e generare previsioni

Ora possiamo distribuire questo model con una sola riga di codice:

endpoint = model.deploy(machine_type="n1-standard-4")

Il metodo deploy richiede un solo argomento: il tipo di macchina su cui eseguire l'inferenza. In realtà non eseguirò la riga sopra perché la distribuzione comporta costi aggiuntivi finché il modello rimane online.

Tuttavia, se la esegui, il metodo deploy restituisce un oggetto Endpoint a cui possiamo inviare richieste:

prediction = endpoint.predict(
   [
       {
           "Area": "30099",
           "Perimeter": "638.8209999999999",
           "MajorAxisLength": "237.14191130827916",
           "MinorAxisLength": "162.3034300714102",
           "AspectRation": "1.4611022774068396",
           "Eccentricity": "0.7290928631259719",
           "ConvexArea": "30477",
           "EquivDiameter": "195.76321681302556",
           "Extent": "0.8036043251902283",
           "Solidity": "0.9875972044492568",
           "roundness": "0.9268374259664279",
           "Compactness": "0.8255108332939839",
           "ShapeFactor1": "0.007878730566074592",
           "ShapeFactor2": "0.002256976927384019",
           "ShapeFactor3": "0.6814681358857279",
           "ShapeFactor4": "0.9956946453228307",
       }
   ]
)

print(prediction)

Dispone di un metodo predict che accetta un elenco di campioni da predire. I campioni devono essere forniti in formato JSON.

Puoi anche usare la dashboard per distribuire i modelli. Se vai nella scheda “MODEL REGISTRY”, vedrai il modello elencato. Clicca sul suo nome e scegli la scheda “DEPLOY & TEST”:

Scheda DEPLOY e TEST del registry dei modelli in Vertex AI

Cliccando sul pulsante ‘DEPLOY TO ENDPOINT’ si accede a una pagina separata in cui configurare la macchina su cui distribuire il modello. Prima di farlo, però, puoi testarlo nell'area sotto il pulsante di distribuzione:

Una GIF che mostra come testare un modello addestrato in Vertex AI usando la UI

Addestrare e distribuire modelli personalizzati in Vertex AI

Distribuire modelli personalizzati in Vertex AI è più impegnativo rispetto ai modelli AutoML e costa anche di più, perché oltre al Workbench e ai costi di distribuzione sono coinvolti alcuni container Docker. Se te la senti, andiamo!

Panoramica ad alto livello del training personalizzato in Vertex AI

Il training personalizzato parte da uno script di addestramento del modello. In questo script possiamo fare qualsiasi cosa purché:

  • Carichi i dati dal bucket GCS
  • Addestri un modello con un framework ML (TF, PyTorch, Scikit-learn, XGBoost)
  • Facoltativamente, esegua il tuning degli iperparametri del modello
  • Lo salvi nel bucket GCS per registrare il modello addestrato o ottimizzato.

Poi questo script di training deve essere convertito in un container Docker e inviato al Google Container Registry. Da lì, possiamo usare l'SDK Python di Vertex AI o la dashboard per addestrare il modello personalizzato.

Creare una struttura di directory per il codice di training

Per prima cosa, creiamo la struttura delle directory come raccomandato da questo codelab di Google. Nel tuo workbench, passa al terminale avviando un nuovo launcher:

Una GIF che mostra come passare al terminale in JupyterLab nel Workbench

Poi crea una nuova directory chiamata “dry-beans” e spostati al suo interno:

$ mkdir dry-beans
$ cd dry-beans/

Dentro dry-beans, crea un'altra directory chiamata trainer e al suo interno il file Python train.py:

$ mkdir trainer
$ touch trainer/train.py

Creare un Dockerfile

Ora crea un nuovo Dockerfile:

$ touch Dockerfile

Apri il file e incolla il seguente contenuto:

FROM gcr.io/deeplearning-platform-release/tf2-cpu.2-6
WORKDIR /

# Copies the trainer code to the docker image.
COPY trainer /trainer

# Install XGBoost
RUN pip install xgboost==1.6.2

# Sets up the entry point to invoke the trainer.
ENTRYPOINT ["python", "-m", "trainer.train"]

Questo Dockerfile utilizza l'immagine ufficiale per il deep learning fornita da Google Container Registry con TensorFlow installato. Il file copia la nostra directory trainer e poi installa XGBoost. Infine, eseguirà il nostro script Python.

Scrivere lo script di training

Lo script deve caricare il dataset Dry Beans dal nostro bucket GCP, addestrare su di esso un classificatore XGBoost e salvare il modello nuovamente sul bucket. Ho scritto uno script semplice che svolge questi compiti in questo gist su GitHub (non lo includo qui per risparmiare spazio).

Copia/incolla il codice del gist in train.py. Poi, di nuovo nel terminale, installa XGBoost poiché non è preinstallato nel Workbench scelto ed esegui lo script:

$ pip install xgboost==1.6.2
$ python trainer/train.py

Creare un'immagine Docker

Se lo script gira senza errori, continua inserendo queste due variabili nel terminale:

$ PROJECT_ID='vertexai-tutorial-423010'  # Replace with your PROJECT_ID from earlier
$ IMAGE_URI="gcr.io/$PROJECT_ID/dry-beans:v1"  # This stays the same

Queste variabili verranno usate quando costruiamo il container, quindi procediamo:

$ docker build ./ -t $IMAGE_URI

La build richiederà un po' di tempo. Al termine, esegui il container per assicurarti che tutto funzioni correttamente:

$ docker run $IMAGE_URI
Model trained successfully!
Model uploaded successfully!

Se ottieni i messaggi di successo sopra, il container è pronto per il push:

$ docker push $IMAGE_URI

Creare un job di training personalizzato

A questo punto il grosso è fatto. Possiamo tornare alla dashboard e creare un job di training personalizzato usando il container appena pubblicato. Vai quindi alla scheda “MODEL REGISTRY” e clicca su “CREATE”:

Creazione di un nuovo job di training personalizzato in Vertex AI

Per il metodo di training, scegli le opzioni “No managed dataset” e “Custom training”. Nel pannello successivo (Model details), dai un nome al modello — dry-beans-classifier.

Nel pannello del training container:

Scelta di un'immagine container per un job di training personalizzato in Vertex AI

Seleziona il container che abbiamo pubblicato come immagine personalizzata e il bucket cloud-ai-platform come output del modello. Quindi clicca su Continue finché non arrivi al pannello "Compute and pricing":

Pannello Compute and pricing del form per il training personalizzato in Vertex AI

Scegli una macchina n1 standard con 4 CPU e infine clicca su "START TRAINING". Poi passa alla scheda "TRAINING" della dashboard.

Uno screenshot della scheda training della dashboard di Vertex AI.

A questo punto vedrai una di queste due situazioni:

  1. Stato di training failed
  2. Stato di training in progress

Nel mio caso è la prima, quindi indaghiamo cliccando sul nome del modello:

Un messaggio di errore da un job di training personalizzato in Vertex AI

L'errore indica che ho superato il numero di CPU consentite per il training personalizzato. Ho approfondito la questione e ciò che ho scoperto è stato piuttosto deludente.

Normalmente, GCP assegna almeno 20 CPU di quota per ogni regione di calcolo, ma controllando il mio profilo ho scoperto che la mia quota era solo 1. Questo significava che non potevo eseguire alcun job di training personalizzato, dato che tutte le macchine offerte da Google hanno almeno due CPU.

Ho provato ad aumentare la quota seguendo le risposte di questo thread su StackOverflow, ma non hanno funzionato. Il messaggio era che i nuovi utenti di Vertex AI hanno diritto solo a una singola unità CPU. Se volevo aumentare la quota, dovevo aprire un ticket al supporto che, a quanto pare, non è gratuito (serve un contratto di supporto a pagamento).

Quindi, se sei sfortunato come me, prova le risposte nel thread SO. Hanno funzionato per alcune persone, ma se non funzionano per te, l'unica opzione è contattare il supporto.

Se invece sei fortunato e il training si conclude, potrai distribuire il modello seguendo gli stessi passaggi descritti per i modelli AutoML.

Conclusione

Vertex AI è una piattaforma enorme, ricca di funzionalità. In questo tutorial abbiamo appena scalfito la superficie, ma abbiamo coperto i mattoni fondamentali della piattaforma. Padroneggiando la creazione di bucket di storage, workbench e job di training, sarai ben attrezzato per esplorare il resto della piattaforma.

Se vuoi saperne di più sui servizi Google Cloud, dai un'occhiata a queste risorse correlate consigliate:

Bexruz (Bex) Tuychiev

Autore

Bexruz (Bex) Tuychiev

Sono un creator di contenuti sulla data science con oltre 2 anni di esperienza e uno dei più seguiti su Medium. Mi piace scrivere articoli dettagliati su AI e ML con un pizzico di sarcasmo, perché bisogna pur fare qualcosa per renderli un po’ meno noiosi. Ho pubblicato oltre 130 articoli e un corso su DataCamp, con un altro in arrivo. I miei contenuti sono stati visti da oltre 5 milioni di persone, 20.000 delle quali sono diventate follower sia su Medium che su LinkedIn. 

Argomenti

Correlato