I data scientist e i machine learning (ML) engineer spesso richiedono che sia abbastanza veloce da soddisfare le esigenze di generazione previsioni online (o in tempo reale) dai modelli ML. Vertex AI è in grado di soddisfare questa esigenza.
Con Vertex AI, puoi fornire modelli da una varietà di ML i modelli di machine learning. Per framework come TensorFlow, PyTorch, XGBoost e scikit-learn, Vertex AI fornisce container predefiniti in cui eseguirli di machine learning. Se non utilizzi già nessuno di questi framework ML, devi per creare il tuo container personalizzato da usare per Vertex AI.
Questo documento è rivolto agli utenti che devono creare un container personalizzato i propri modelli Spark ML. Il presente documento include sia una descrizione dei necessaria per i container personalizzati e un'implementazione di riferimento che dimostra questa architettura per un modello Spark MLib.
Per sfruttare al meglio questa sezione di questo documento sull'implementazione dei riferimenti, dovresti avere familiarità con l'esportazione dei modelli Spark MLlib MLeap, per capire come utilizzare Vertex AI per la pubblicazione di previsioni e esperienza nell'uso delle immagini container.
Architettura
Sebbene i container predefiniti siano disponibili per alcuni framework ML, gli utenti di altri i framework ML, come Spark, devono creare container personalizzati in cui Vertex AI può eseguire previsioni. Il seguente diagramma illustra l'architettura di gestione necessaria per gestire i modelli Spark MLib e altri che richiedono un container personalizzato:
Questa architettura include i seguenti componenti:
- Cloud Storage: fornisce spazio di archiviazione per gli artefatti del modello necessari per l'esecuzione del modello. Per il modello Spark ML utilizzato nel riferimento gli artefatti del modello sono costituiti Pacchetto MLeap e uno schema del modello.
- Cloud Build: utilizza l'immagine del builder per creare un'immagine container personalizzata chiamata immagine del container di pubblicazione. Il processo di compilazione compila e pacchettizza il codice di pubblicazione del modello, crea l'immagine del container di pubblicazione ed esegue il push l'immagine del container di distribuzione in Artifact Registry.
- Artifact Registry: contiene i seguenti oggetti:
- .
- L'immagine container del builder
scala-sbt
utilizzata da Cloud Build per creare l'immagine container di pubblicazione. - L'immagine del container di pubblicazione creata da Cloud Build.
- L'immagine container del builder
- Vertex AI: contiene il modello ML che è stato caricato da Cloud Storage. Il modello caricato è configurato con località degli artefatti del modello all'interno di Cloud Storage, dell'immagine container di distribuzione in Artifact Registry. Vertex AI include anche un endpoint in cui è stato eseguito il deployment del modello. Quando il modello di cui è stato eseguito il deployment nell'endpoint, risorse fisiche con il modello, in modo che quest'ultimo possa fornire previsioni online.
Nell'ambito dell'implementazione di questa architettura di pubblicazione, dovrai esportare modello ML per l'utilizzo da parte di altre applicazioni e definizione del tuo container di pubblicazione dell'immagine. L'implementazione del riferimento fornita in questo documento fornisce il codice utilizzato per definire e creare l'immagine container di pubblicazione. Questo codice include anche gli artefatti del modello per un modello Spark ML esportato in precedenza. Con alcuni modifiche alla configurazione, puoi utilizzare questa implementazione di riferimento per i tuoi modelli Spark ML.
Tuttavia, puoi implementare questa architettura di pubblicazione autonomamente e non utilizzare come riferimento dell'implementazione. Se decidi di implementare una tua architettura, eseguire le seguenti operazioni:
- Esporta il modello in modo che possa essere utilizzato da altre applicazioni. Questo processo dipende dai framework ML e dagli strumenti che usi. Ad esempio, potresti scegliere di esportare i tuoi modelli Spark MLlib creando un bundle MLeap come descritti nell'implementazione dei riferimenti. Puoi vedere altri esempi di come per esportare i modelli Esporta gli artefatti del modello per la previsione.
- Progetta l'immagine del container di pubblicazione in modo da soddisfare i requisiti dei container personalizzati che rendono l'immagine compatibile con Vertex AI. Il codice può essere nel linguaggio di programmazione che preferisci.
- Pacchettizzare il codice in un formato file di pacchetto compatibile con la programmazione la lingua utilizzata. Ad esempio, puoi utilizzare un file JAR per il codice Java una ruota Python per il codice Python.
- Crea un'immagine container personalizzata in grado di gestire la tua modalità personalizzata le API nel tuo codice.
Implementazione dei riferimenti
La seguente implementazione di riferimento pubblica un modello Spark MLib che prevede le specie di iris in base alla lunghezza e alla larghezza dei sepali dei fiori e petali.
Puoi trovare il modello utilizzato in questa implementazione nel
Directory example_model
nel repository vertex-ai-spark-ml-serving.git
.
La directory contiene gli artefatti del modello utilizzati
container per eseguire previsioni e include i seguenti file:
- Il file
example_model/model.zip
è un modello di regressione logistica che è stato creato con Spark MLlib, è stato addestrato utilizzando Set di dati Iris, ed è stato convertito in un bundle MLeap. Il modello prevede la specie di un fiore di iris usando la lunghezza e la larghezza dei sepali e petali. - Il file
example_model/schema.json
è un file JSON che descrive schema del modello. Lo schema del modello descrive i campi di immissione previsti le istanze di previsione e i campi di output per i risultati richiesto per lo schema MLeap.
Utilizza il tuo modello Mlib
Per utilizzare il tuo modello con questa implementazione di riferimento, assicurati innanzitutto che il tuo modello Spark MLlib è stato esportato in un pacchetto MLeap. Quindi, per pubblicare il tuo modello Spark MLib, devi fornire il modello appropriato artefatti: il bundle MLeap e lo schema del modello.
Pacchetto MLeap
Il container di pubblicazione determina la posizione del bundle MLeap utilizzando il metodo
Variabile di ambiente AIP_STORAGE_URI
che viene passato da Vertex AI al container all'avvio. La
viene specificato il valore della variabile AIP_STORAGE_URI
quando carichi il modello
a Vertex AI.
Schema modello
Lo schema del modello descrive le caratteristiche di input e l'output della previsione di un modello. La lo schema del modello viene rappresentato utilizzando dati JSON. Di seguito è riportato lo schema utilizzato in questa implementazione di riferimento per prevedere le specie di iris in base alla lunghezza e larghezza dei sepali e dei petali del fiore:
{ "input": [ { "name": "sepal_length", "type": "FLOAT" }, { "name": "sepal_width", "type": "FLOAT" }, { "name": "petal_length", "type": "FLOAT" }, { "name": "petal_width", "type": "FLOAT" } ], "output": [ { "name": "probability", "type": "DOUBLE", "struct": "VECTOR" } ] }
Nello schema di esempio, l'array input
contiene i campi di input (colonne) per
il modello mentre l'array output
contiene i campi di output (colonne) da
restituito dal modello. In entrambi gli array, ciascun oggetto dell'array contiene
seguenti proprietà:
name
: il nome del campo (colonna).type
: il tipo di campo (colonna). I tipi validi sonoBOOLEAN
,BYTE
,DOUBLE
,FLOAT
,INTEGER
,LONG
,SHORT
eSTRING
.- (Facoltativo)
struct
: la struttura dei campi, ad esempio uno scalare o uno array. Le strutture valide includonoBASIC
(tipo di scala),ARRAY
(SparkArray
), eVECTOR
(SparkDenseVector
).BASIC
viene utilizzato se il campostruct
non è presente.
Per passare lo schema del modello al container di pubblicazione, puoi utilizzare una delle seguenti opzioni: seguenti metodi:
- Specifica i dati JSON che definiscono lo schema nel campo
MLEAP_SCHEMA
variabile di ambiente. La variabile di ambienteMLEAP_SCHEMA
deve i dati JSON e non un percorso di un file che contiene Schema JSON. - Archivia i dati JSON in un file denominato
schema.json
e crea questo file disponibili per il container all'indirizzo${AIP_STORAGE_URI}/schema.json
. Questo è il utilizzato per il modello MLib di esempio fornito con questo documentazione.
Se utilizzi entrambi i metodi per passare lo schema del modello al container di pubblicazione,
I dati JSON archiviati nella variabile di ambiente MLEAP_SCHEMA
richiedono
la precedenza.
Costi
Questa implementazione di riferimento utilizza i seguenti componenti fatturabili di Google Cloud:
Per generare una stima dei costi basata sull'utilizzo previsto, utilizza Calcolatore prezzi.
Al termine di questa implementazione di riferimento, puoi evitare di continuare a fatturare eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Esegui la pulizia.
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.
-
Abilita le API Vertex AI, Cloud Build, Cloud Storage, and Artifact Registry.
-
In the Google Cloud console, activate Cloud Shell.
- Trova il tuo ID progetto e impostalo in Cloud Shell.
export PROJECT_ID=YOUR_PROJECT_ID gcloud config set project ${PROJECT_ID}
Sostituisci
YOUR_PROJECT_ID
con l'ID progetto.
Crea l'immagine del builder scala-sbt
Utilizzi Cloud Build con
Strumento per la creazione della community di scala-sbt
per creare l'immagine container di pubblicazione. Questo processo di compilazione dipende dalla
Immagine del builder di sbt-scala
nel Container Registry del tuo progetto.
In Cloud Shell, clona il repository
cloud-builders-community
:git clone https://github.com/GoogleCloudPlatform/cloud-builders-community.git
Vai alla directory del progetto:
cd cloud-builders-community/scala-sbt
Crea l'immagine del builder
scala-sbt
ed eseguine il push a Container Registry:gcloud builds submit .
Crea l'immagine container di pubblicazione
Vertex AI utilizza il container di gestione per eseguire richieste di previsione per il modello di esempio. Il primo passaggio per la creazione dell'immagine container di pubblicazione è creare un repository Docker in Artifact Registry in cui archiviare dell'immagine. Poi devi concedere a Vertex AI Autorizzazione per eseguire il pull dell'immagine container di gestione dal repository. Dopo aver creato il repository e concedere le autorizzazioni, puoi creare l'immagine container di pubblicazione ed eseguire il push in Artifact Registry.
In Cloud Shell, crea un repository Docker in Artifact Registry:
REPOSITORY="vertex-ai-prediction" LOCATION="us-central1" gcloud artifacts repositories create $REPOSITORY \ --repository-format=docker \ --location=$LOCATION
Concedi Ruolo Lettore Artifact Registry all'agente di servizio Vertex AI:
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \ --format="value(projectNumber)") SERVICE_ACCOUNT="service-$PROJECT_NUMBER@gcp-sa-aiplatform.iam.gserviceaccount.com" gcloud projects add-iam-policy-binding $PROJECT_ID \ --member="serviceAccount:$SERVICE_ACCOUNT" \ --role="roles/artifactregistry.reader"
Clona il repository
spark-ml-serving
:git clone https://github.com/GoogleCloudPlatform/vertex-ai-spark-ml-serving.git
Vai alla directory del progetto:
cd vertex-ai-spark-ml-serving
Crea l'immagine container di pubblicazione nel tuo progetto:
IMAGE=spark-ml-serving gcloud builds submit --config=cloudbuild.yaml \ --substitutions="_LOCATION=$LOCATION,_REPOSITORY=$REPOSITORY,_IMAGE=$IMAGE" .
Il file
cloudbuild.yaml
specifica due builder:scala-sbt
e ai Strumento per la creazione di immagini didocker
. Cloud Build utilizzascala-sbt
Builder da cui compilare il codice di pubblicazione del modello Cloud Storage, quindi pacchettizzare il codice compilato in un file JAR eseguibile. Cloud Build utilizza lo strumento di creazionedocker
per creare un'immagine container di pubblicazione contenente il file JAR. Dopo la pubblicazione dell'immagine container, viene eseguito il push dell'immagine su Artifact Registry.
Importa il modello in Vertex AI
Il container di pubblicazione legge gli artefatti del modello da Cloud Storage. Tu devi creare una posizione di archiviazione per questi artefatti prima di importare in Vertex AI. Quando poi importi il modello, è necessario sia la posizione di archiviazione dell'artefatto del modello che l'immagine container Artifact Registry.
In Cloud Shell, crea un bucket per gli artefatti del modello:
REGION="us-central1" BUCKET="YOUR_BUCKET_NAME" gcloud storage buckets create gs://$BUCKET --location=$REGION
Sostituisci
YOUR_BUCKET_NAME
con il nome del tuo bucket.Copia gli artefatti del modello nel bucket:
gcloud storage cp example_model/* gs://$BUCKET/example_model/
Importa il modello in Vertex AI:
DISPLAY_NAME="iris-$(date +'%Y%m%d%H%M%S')" IMAGE_URI="${LOCATION}-docker.pkg.dev/$PROJECT_ID/${REPOSITORY}/${IMAGE}" ARTIFACT_URI="gs://$BUCKET/example_model/" gcloud ai models upload \ --region=$REGION \ --display-name=$DISPLAY_NAME \ --container-image-uri=$IMAGE_URI \ --artifact-uri=$ARTIFACT_URI \ --container-health-route="/health" \ --container-predict-route="/predict"
Nel comando
gcloud ai models upload
, il valore dell'attributo--artifact-uri
specifica il valore della variabileAIP_STORAGE_URI
. Questo fornisce la posizione del bundle MLeap che viene importato Vertex AI.
esegui il deployment del modello su un nuovo endpoint
Affinché Vertex AI esegua le previsioni, il modello importato deve essere il deployment in un endpoint. Sono necessari sia l'ID dell'endpoint che l'ID del modello quando esegui il deployment del modello.
In Cloud Shell, crea l'endpoint del modello:
gcloud ai endpoints create \ --region=$REGION \ --display-name=$DISPLAY_NAME
Lo strumento a riga di comando
gcloud
potrebbe richiedere alcuni secondi per creare endpoint.Recupera l'ID dell'endpoint appena creato:
ENDPOINT_ID=$(gcloud ai endpoints list \ --region=$REGION \ --filter=display_name=$DISPLAY_NAME \ --format='value(name)') # Print ENDPOINT_ID to the console echo "Your endpoint ID is: $ENDPOINT_ID"
Recupera l'ID del modello importato nella Importa il modello in Vertex AI sezione:
MODEL_ID=$(gcloud ai models list \ --region=$REGION \ --filter=display_name=$DISPLAY_NAME \ --format='value(name)') # Print MODEL_ID to the console echo "Your model ID is: $MODEL_ID"
Esegui il deployment del modello nell'endpoint:
gcloud ai endpoints deploy-model $ENDPOINT_ID \ --region=$REGION \ --model=$MODEL_ID \ --display-name=$DISPLAY_NAME \ --traffic-split="0=100"
Il comando
gcloud
esegue il deployment del modello nell'endpoint. I valori predefiniti sono utilizzata per il tipo di risorsa della macchina, il numero minimo e massimo nodi e altre opzioni di configurazione. Per ulteriori informazioni sul deployment, per i modelli, consulta le Documentazione di Vertex AI.
Testa l'endpoint
Dopo aver eseguito il deployment del modello nell'endpoint, puoi testare
implementazione. Per testare l'endpoint, puoi usare il client di esempio
incluso nel codice di implementazione del riferimento. Il client di esempio genera
le istanze di previsione e invia richieste di previsione all'endpoint. Ciascuna
l'istanza di previsione contiene valori randomizzati per sepal_length
,
sepal_width
, petal_length
e petal_width
. Per impostazione predefinita, il client di esempio
combina più istanze di previsione in una singola richiesta. La risposta di
la risposta dell'endpoint include una previsione per ogni istanza inviata
la richiesta. La previsione contiene le probabilità per ogni classe nel
Set di dati Iris (setosa
, versicolor
e virginica
).
In Cloud Shell, esegui il client di previsione di esempio:
cd example_client ./run_client.sh --project $PROJECT_ID \ --location $LOCATION \ --endpoint $ENDPOINT_ID
Quando esegui lo script per la prima volta, viene creato un file Python un ambiente virtuale e installa le dipendenze. Dopo l'installazione le dipendenze, lo script esegue il client di esempio. Per ogni richiesta, il client stampa le istanze di previsione e le probabilità delle classi corrispondenti al terminale. Di seguito è riportato un estratto dell'output:
Sending 10 asynchronous prediction requests with 3 instances per request ... ==> Response from request #10: Instance 1: sepal_length: 5.925825137450266 sepal_width: 4.5047557888651 petal_length: 1.0432434310300223 petal_width: 0.5050397721287457 Prediction 1: setosa: 0.2036041134824573 versicolor: 0.6062980065549213 virginica: 0.1900978799626214 Instance 2: sepal_length: 6.121228622484405 sepal_width: 3.406317728235072 petal_length: 3.178583759980504 petal_width: 2.815141143581328 Prediction 2: setosa: 0.471811302254083 versicolor: 0.2063720436033448 virginica: 0.3218166541425723 Instance 3: sepal_length: 7.005781590327274 sepal_width: 2.532116893508745 petal_length: 2.6351337947193474 petal_width: 2.270855223519198 Prediction 3: setosa: 0.453579051699638 versicolor: 0.2132869980698818 virginica: 0.3331339502304803
Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse usati in questa implementazione di riferimento, elimina il progetto che contiene le risorse o mantenere il progetto ed eliminare le singole risorse.
Elimina il progetto
- 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.
Elimina singole risorse
In Cloud Shell, annulla il deployment del modello dall'endpoint:
DEPLOYED_MODEL_ID=$(gcloud ai endpoints describe $ENDPOINT_ID \ --region=$REGION \ --format='value(deployedModels.id)') gcloud ai endpoints undeploy-model $ENDPOINT_ID \ --region=$REGION \ --deployed-model-id=$DEPLOYED_MODEL_ID
Elimina l'endpoint:
gcloud ai endpoints delete $ENDPOINT_ID \ --region=$REGION \ --quiet
Elimina il modello:
gcloud ai models delete $MODEL_ID \ --region=$REGION
Elimina l'immagine del container di pubblicazione:
gcloud artifacts docker images delete \ $LOCATION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE \ --delete-tags \ --quiet
Elimina il container del builder di
scala-sbt
:gcloud container images delete gcr.io/$PROJECT_ID/scala-sbt \ --force-delete-tags \ --quiet
Elimina tutti i bucket Cloud Storage che non sono più necessari:
gcloud storage rm YOUR_BUCKET_NAME --recursive
L'eliminazione di un bucket comporta anche l'eliminazione di tutti gli oggetti archiviati al suo interno. I bucket e gli oggetti eliminati non possono essere recuperati dopo l'eliminazione.
Passaggi successivi
- Scopri di più su eseguire previsioni con Vertex AI.
- Scopri di più su Spark su Google Cloud.
- Per altre architetture di riferimento, diagrammi e best practice, esplora il Centro architetture cloud.