Questa versione precedente di AI Platform Prediction è ritirata e non sarà più disponibile su Google Cloud dopo il 31 gennaio 2025. Tutti i modelli, i metadati e i deployment associati verranno eliminati dopo il 31 gennaio 2025. Esegui la migrazione delle tue risorse a Vertex AI per ottenere nuove funzionalità di machine learning che non sono disponibili in AI Platform.

Questa pagina è stata tradotta dall'API Cloud Translation.

Deployment dei modelli

Questa pagina spiega come eseguire il deployment del modello in AI Platform Prediction per ottenere per le previsioni.

Per eseguire il deployment del tuo modello addestrato su AI Platform Prediction, devono:

Carica il modello salvato in un bucket Cloud Storage.
Crea una risorsa del modello AI Platform Prediction.
Crea una risorsa di versione di AI Platform Prediction, specificando il percorso Cloud Storage del modello salvato.

Prima di iniziare

Addestra il tuo modello di machine learning e segui la guida all'esportazione dei modelli per previsione per creare artefatti del modello di cui è possibile eseguire il deployment in AI Platform Prediction.

Archivia il modello in Cloud Storage

In genere, è più semplice utilizzare un bucket Cloud Storage dedicato nello stesso che stai utilizzando per AI Platform Prediction.

Se utilizzi un bucket in un altro progetto, devi assicurarti che L'account di servizio AI Platform Prediction può accedere al modello in di archiviazione ideale in Cloud Storage. Senza le autorizzazioni appropriate, la tua richiesta di creare un La versione del modello AI Platform Prediction ha esito negativo. Scopri di più su concedere autorizzazioni per l'archiviazione.

Configura il tuo bucket Cloud Storage

Questa sezione mostra come creare un nuovo bucket. Puoi utilizzare un modello esistente ma deve trovarsi nella stessa regione in cui prevedi di eseguire AI Platform di lavoro. Inoltre, se non fa parte del progetto che utilizzi per eseguire AI Platform Prediction, devi generare concedere l'accesso agli account di servizio AI Platform Prediction.

Specifica un nome per il nuovo bucket. Il nome deve essere univoco in tutti in Cloud Storage.
```
BUCKET_NAME="YOUR_BUCKET_NAME"
```
Ad esempio, utilizza il nome del progetto aggiungendo -aiplatform:
```
PROJECT_ID=$(gcloud config list project --format "value(core.project)")
BUCKET_NAME=${PROJECT_ID}-aiplatform
```
Controlla il nome del bucket che hai creato.
```
echo $BUCKET_NAME
```
Seleziona una regione per il bucket e imposta una variabile di ambiente REGION.

Utilizza la stessa regione in cui prevedi di eseguire AI Platform Prediction di lavoro. Scopri le regioni in cui è disponibile per Servizi di AI Platform Prediction.

Ad esempio, il seguente codice crea REGION e lo imposta su us-central1:
```
REGION=us-central1
```

Crea il nuovo bucket:

gcloud storage buckets create gs://$BUCKET_NAME --location=$REGION

Carica il modello esportato in Cloud Storage

I seguenti esempi mostrano come caricare diversi tipi di artefatti del modello di una directory del modello in Cloud Storage:

SavedModel di TensorFlow

SAVED_MODEL_DIR=$(ls ./YOUR_EXPORT_DIR_BASE | tail -1)
gcloud storage cp $SAVED_MODEL_DIR gs://YOUR_BUCKET --recursive

Quando esporti un SavedModel da tf.keras o da un modello TensorFlow, stimatore, viene salvata come sottodirectory con timestamp di una directory di esportazione di base ad esempio YOUR_EXPORT_DIR_BASE/1487877383942. Questo esempio mostra come caricare la directory con il timestamp più recente. Se hai creato il SavedModel in un modo diverso, potrebbe essere posizione sul tuo file system locale.

File del modello scikit-learn o XGBoost

A seconda di come hai esportato i dati modello, carica il tuo model.joblib, model.pkl o model.bst.

L'esempio seguente mostra come caricare un file esportato da sklearn.externals.joblib:

gcloud storage cp ./model.joblib gs://YOUR_BUCKET/model.joblib

L'esempio seguente mostra come caricare un file esportato dall'pickle di Python modulo:

gcloud storage cp ./model.pkl gs://YOUR_BUCKET/model.pkl

L'esempio seguente mostra come caricare un file esportato da Metodo save_model di xgboost.Booster:

gcloud storage cp ./model.bst gs://YOUR_BUCKET/model.bst

Se esegui il deployment di una routine di previsione personalizzata (beta), carica eventuali modelli aggiuntivi anche gli artefatti nella directory del modello.

Le dimensioni totali del file della directory del modello devono essere 500 MB oppure meno se utilizzi un tipo di macchina legacy (MLS1) o 10 GB o meno se utilizzi Tipo di macchina Compute Engine (N1). Scopri di più sui tipi di macchine per la vendita online per la previsione.

Quando crei versioni successive del tuo modello, organizzale posizionando una nella propria directory separata all'interno del bucket Cloud Storage.

Carica codice personalizzato

Se esegui il deployment di una pipeline scikit-learn con un codice personalizzato di previsione, devi anche Caricare il pacchetto di distribuzione di origine contenente il codice personalizzato. Ad esempio:

gcloud storage cp dist/my_custom_code-0.1.tar.gz gs://YOUR_BUCKET/my_custom_code-0.1.tar.gz

Puoi caricare questo tarball nella stessa directory in Cloud Storage come il file del modello, ma non è necessario. Di fatto, mantenerli separati può migliorare l'organizzazione, soprattutto se esegui il deployment di molte versioni modello e codice.

Testa il modello con previsioni locali

Puoi utilizzare lo gcloud ai-platform local predict per testare il modo in cui il modello fornisce le previsioni prima di eseguirne il deployment AI Platform Prediction. Il comando utilizza le dipendenze nel tuo ambiente locale eseguire la previsione e restituire i risultati nello stesso formato gcloud ai-platform predict quando esegue previsioni online. Eseguire test locali sulle previsioni può essere utile scoprirai errori prima che ti vengano addebitati i costi per le richieste di previsione online.

Per l'argomento --model-dir, specifica una directory contenente il tuo modello di machine learning esportato, sul tuo computer locale di archiviazione ideale in Cloud Storage. Per l'argomento --framework, specifica tensorflow, scikit-learn o xgboost. Non puoi utilizzare Comando gcloud ai-platform local predict con una previsione personalizzata di Google Cloud.

L'esempio seguente mostra come eseguire una previsione locale:

gcloud ai-platform local predict --model-dir LOCAL_OR_CLOUD_STORAGE_PATH_TO_MODEL_DIRECTORY/ \
  --json-instances LOCAL_PATH_TO_PREDICTION_INPUT.JSON \
  --framework NAME_OF_FRAMEWORK

Esegui il deployment di modelli e versioni

AI Platform Prediction organizza i modelli addestrati utilizzando modello e Risorse della versione. Un modello AI Platform Prediction è un container per più versioni del tuo modello di machine learning.

Per eseguire il deployment di un modello, crea una risorsa del modello in AI Platform Prediction, crea una versione del modello, poi collegala al file del modello archiviato di archiviazione ideale in Cloud Storage.

Crea una risorsa del modello

AI Platform Prediction utilizza le risorse del modello per organizzare le diverse versioni del modello.

Al momento devi decidere se vuoi utilizzare versioni del modello appartenenti a questo questo modello per utilizzare un endpoint a livello di regione o endpoint. Nella maggior parte dei casi, scegli un'area geografica endpoint. Se hai bisogno di funzionalità che siano disponibili solo su tipi di macchine legacy (MLS1), quindi utilizza l'endpoint globale.

Al momento devi anche decidere se vuoi che le versioni del modello appartenenti a questo per esportare tutti i log quando forniscono previsioni. I seguenti esempi includono non abilitare il logging. Scopri come attivare la funzionalità il logging.

console

Apri la pagina Modelli di AI Platform Prediction nella Console Google Cloud:

Vai alla pagina Modelli
Fai clic sul pulsante Nuovo modello nella parte superiore della pagina Modelli. Questo per accedere alla pagina Crea modello.
Inserisci un nome univoco per il modello nel campo Nome modello.
Quando la casella di controllo Utilizza endpoint a livello di regione è selezionata, AI Platform Prediction utilizza un endpoint a livello di regione. Per utilizzare endpoint globale Deseleziona la casella di controllo Usa endpoint a livello di regione.
Nell'elenco a discesa Regione, seleziona una località per la previsione nodi. Le regioni disponibili variano a seconda sia che utilizzi un endpoint a livello di regione o di endpoint globale.
Fai clic su Crea.
Verifica di essere tornato alla pagina Modelli e che il nuovo questo modello viene visualizzato nell'elenco.

gcloud

Endpoint a livello di regione

Esegui questo comando:

gcloud ai-platform models create MODEL_NAME \
  --region=REGION

Sostituisci quanto segue:

MODEL_NAME: un nome scelto da te per il modello.
REGION: la regione della regione endpoint in cui vuoi eseguire la previsione nodi da eseguire. Deve essere una regione che supporta Tipi di macchine di Compute Engine (N1).

Se non specifichi il flag --region, allora gcloud CLI ti chiede di selezionare un endpoint a livello di regione (o di utilizzare us-central nella endpoint globale).

In alternativa, puoi impostare il ai_platform/region a una regione specifica per assicurarti che gcloud CLI utilizzi sempre l'endpoint regionale corrispondente per AI Platform Prediction, anche quando non specifichi il flag --region. Questa configurazione non è applicabile ai comandi gcloud ai-platform operations gruppo di comandi).

Endpoint globale

Esegui questo comando:

gcloud ai-platform models create MODEL_NAME \
  --regions=REGION

Sostituisci quanto segue:

MODEL_NAME: un nome scelto da te per il modello.
REGION: la regione sull'endpoint globale in cui vuoi nodi di previsione da eseguire. Deve essere una regione che supporta tipi di macchine legacy (MLS1).

Se non specifichi il flag --regions, allora gcloud CLI ti chiede di selezionare un endpoint a livello di regione (oppure usa us-central1 sull'endpoint globale).

API REST

Endpoint a livello di regione

Formatta la richiesta inserendo l'oggetto modello nella corpo della richiesta. Come minimo, specifica un nome per il modello sostituendo MODEL_NAME nel seguente esempio:
```
{
  "name": "MODEL_NAME"
}
```
Effettua una chiamata API REST al seguente URL, sostituendo PROJECT_ID con il tuo ID progetto Google Cloud:
```
POST https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models/
```
Sostituisci quanto segue:
- REGION: la regione dell'endpoint a livello di regione di cui eseguire il deployment del modello. Deve essere una regione che supporta Tipi di macchine di Compute Engine (N1).
- PROJECT_ID: l'ID del tuo progetto Google Cloud.
Ad esempio, puoi effettuare la richiesta seguente utilizzando l'curl . Questo comando autorizza la richiesta utilizzando le credenziali associati a Google Cloud CLI l'installazione.
```
curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "MODEL_NAME"}' \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  "https://REGION-ml.googleapis.com/v1/projects/PROJECT_ID/models"
```
L'API restituisce una risposta simile alla seguente:
```
{
  "name": "projects/PROJECT_ID/models/MODEL_NAME",
  "regions": [
    "REGION"
  ]
}
```

Endpoint globale

Formatta la richiesta inserendo l'oggetto modello nella corpo della richiesta. Come minimo, specifica un nome per il modello sostituendo MODEL_NAME nel seguente esempio e specifica una regione per sostituendo REGION con una regione che supporta tipi di macchine legacy (MLS1):
```
{
  "name": "MODEL_NAME",
  "regions": ["REGION"]
}
```

Effettua una chiamata API REST al seguente URL, sostituendo PROJECT_ID con il tuo ID progetto Google Cloud:

POST https://ml.googleapis.com/v1/projects/PROJECT_ID/models/

Ad esempio, puoi effettuare la richiesta seguente utilizzando l'curl . Questo comando autorizza la richiesta utilizzando le credenziali associati a Google Cloud CLI l'installazione.

curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "MODEL_NAME", "regions": ["REGION"]}' \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  "https://ml.googleapis.com/v1/projects/PROJECT_ID/models"

L'API restituisce una risposta simile alla seguente:

{
  "name": "projects/PROJECT_ID/models/MODEL_NAME",
  "regions": [
    "REGION"
  ]
}

Per ulteriori dettagli, consulta l'API AI Platform Prediction.

Crea una versione del modello

Ora è tutto pronto per creare una versione del modello con il modello addestrato che in precedenza in Cloud Storage. Quando crei una versione, puoi specificare un certo numero di parametri. Il seguente elenco descrive i parametri comuni, alcuni dei quali sono obbligatori:

name: deve essere univoco all'interno del modello AI Platform Prediction.
deploymentUri: il percorso del modello in di archiviazione ideale in Cloud Storage.
- Se esegui il deployment di un modello TensorFlow, Directory SavedModel.
- Se esegui il deployment di un modello scikit-learn o XGBoost, questa è la directory contenente model.joblib, model.pkl o model.bst file.
- Se esegui il deployment di una routine di previsione personalizzata, questa è la directory contenente tutti gli artefatti del tuo modello. Le dimensioni totali di questa directory devono essere massimo 500 MB.
framework: TENSORFLOW, SCIKIT_LEARN o XGBOOST. Ometti questo parametro se esegui il deployment una routine di previsione personalizzata.
runtimeVersion: una versione di runtime basata su sulle dipendenze necessarie per il modello. Se esegui il deployment di un modello un modello XGBoost o un modello routine di previsione, il valore almeno 1,4. Se hai intenzione di usa la versione del modello per la previsione batch, quindi devi utilizzare la versione del runtime 2.1 o precedente.
(Facoltativo) packageUris: un elenco di percorsi verso la distribuzione del codice personalizzato pacchetti (.tar.gz file) in Cloud Storage. Fornisci solo questo se esegui il deployment di una pipeline scikit-learn con (beta) o un routine di previsione personalizzata (beta).
predictionClass (facoltativo): il nome della tua classe Predictor in module_name.class_name. Fornisci questo parametro solo se esegui il deployment di una previsione personalizzata (beta).
serviceAccount (facoltativo): puoi specificare una account di servizio per la versione del modello da utilizzare se accede le risorse Google Cloud durante la fornitura delle previsioni. Scopri di più su specificando un account di servizio. Solo fornisci questo parametro se utilizzi un modello personalizzato container o una previsione personalizzata .
pythonVersion: deve essere impostato su "3,5" (per le versioni di runtime da 1.4 a 1,14) o "3,7" (per runtime versioni 1.15 e successive) per essere compatibile con i file di modello esportati con Python 3. Può essere impostato anche su "2,7" se utilizzato con della versione 1.15 o precedenti del runtime.
(Facoltativo) machineType: il tipo di macchina virtuale utilizzato da AI Platform Prediction per i nodi che forniscono previsioni. Scopri di più sui modelli tipi. Se non viene configurato, il valore predefinito è n1-standard-2 per gli endpoint a livello di regione e mls1-c1-m2 sull'endpoint globale.

Se la versione del modello utilizza un tipo di macchina Compute Engine (N1) e meno di due nodi, viene esclusa dal Servizio di addestramento e previsione di AI Platform Accordo sul livello del servizio (SLA).

In altre parole, se utilizzi un tipo di macchina Compute Engine (N1), devi impostare manualScaling.nodes o autoScaling.minNodes a 2 o a un livello superiore affinché la versione del modello sia coperta dallo SLA (accordo sul livello del servizio).

Inoltre, l'utilizzo della scalabilità automatica con le GPU è disponibile in preview; Di conseguenza, le versioni del modello che utilizzano la scalabilità automatica con GPU non è coperta dallo SLA.

Visualizza più informazioni su ciascuno di questi parametri e altre informazioni parametri comuni, nel riferimento API per la risorsa versione.

Inoltre, se hai creato il modello su un endpoint a livello di regione, assicurati di Inoltre, crea la versione nella stessa regione endpoint.

console

Apri la pagina Modelli di AI Platform Prediction nella Console Google Cloud:

Vai alla pagina Modelli
Nella pagina Modelli, seleziona il nome della risorsa del modello che vuoi vuoi usare per creare la tua versione. Questo ti porta Pagina Dettagli modello.
Fai clic sul pulsante Nuova versione nella parte superiore dei Dettagli modello . Viene visualizzata la pagina Crea versione.
Inserisci il nome della tua versione nel campo Nome. Se vuoi, inserisci un della versione nel campo Descrizione.
Inserisci le seguenti informazioni su come hai addestrato il tuo modello nella caselle a discesa corrispondenti:
- Seleziona la versione Python che hai utilizzato per addestrare il modello.
- Seleziona la Versione frame e Framework. Se stai implementando una versione personalizzata routine di previsione (beta), seleziona "Routine di previsione personalizzata (BETA)" per Framework.
- Seleziona la versione del runtime ML. Scopri di più su Versioni del runtime di AI Platform Prediction.
Seleziona una macchina tipo per eseguirlo online la previsione.
Nel campo URI modello, inserisci la località del bucket Cloud Storage in cui hai caricato il file del modello. Puoi utilizzare il pulsante Sfoglia per trovare il percorso corretto.

Assicurati di specificare il percorso della directory contenente il file. non il percorso del file del modello stesso. Ad esempio, utilizza gs://your_bucket_name/model-dir/ anziché gs://your_bucket_name/model-dir/saved_model.pb o gs://your_bucket_name/model-dir/model.pkl.
Se esegui il deployment di una pipeline scikit-learn con codice personalizzato (beta) o un routine di previsione personalizzata (beta), fornisci Percorso Cloud Storage di eventuali pacchetti di codice personalizzati (.tar.gz) in Codice personalizzato e dipendenze. Se esegui il deployment routine di previsione personalizzata, inserisci il nome del tuo predittore nel Campo Classe di previsione.
Seleziona un'opzione di Scalabilità per il deployment delle previsioni online:
- Se selezioni "Scalabilità automatica", il campo Viene visualizzato il campo Numero minimo di nodi. Puoi inserire il parametro di nodi da mantenere sempre in esecuzione, quando è stato fatto lo scale down del servizio.
- Se selezioni "Scalabilità manuale", devi inserire Numero di nodi che vuoi mantenere sempre in esecuzione.
Scopri come le opzioni di scalabilità variano in base al computer del testo.

Scopri di più su per i costi di previsione.
Per completare la creazione della versione del modello, fai clic su Salva.

gcloud

Imposta le variabili di ambiente per archiviare il percorso di Cloud Storage directory in cui si trova il file binario del modello, il nome del modello, il nome della versione e la scelta del framework.

Quando crei una versione con gcloud CLI, puoi fornire il nome del framework in maiuscolo con trattini bassi (ad esempio, SCIKIT_LEARN) o in lettere minuscole con trattini (ad esempio, scikit-learn). Entrambe le opzioni generano un comportamento identico.

Sostituisci [VALUES_IN_BRACKETS] con i valori appropriati:
```
MODEL_DIR="gs://your_bucket_name/"
VERSION_NAME="[YOUR-VERSION-NAME]"
MODEL_NAME="[YOUR-MODEL-NAME]"
FRAMEWORK="[YOUR-FRAMEWORK_NAME]"
```
Per una pipeline scikit-learn con codice (beta), imposta una variabile aggiuntiva con il percorso del codice personalizzato Tarball:
```
MODEL_DIR="gs://your_bucket_name/"
VERSION_NAME="[YOUR-VERSION-NAME]"
MODEL_NAME="[YOUR-MODEL-NAME]"
FRAMEWORK="scikit-learn"
CUSTOM_CODE_PATH="gs://your_bucket_name/my_custom_code-0.1.tar.gz"
```
Per una previsione personalizzata (beta), ometti il FRAMEWORK e imposta altre variabili con il percorso da il tarball del codice personalizzato e il nome della classe di predittore:
```
MODEL_DIR="gs://your_bucket_name/"
VERSION_NAME="[YOUR-VERSION-NAME]"
MODEL_NAME="[YOUR-MODEL-NAME]"
CUSTOM_CODE_PATH="gs://your_bucket_name/my_custom_code-0.1.tar.gz"
PREDICTOR_CLASS="[MODULE_NAME].[CLASS_NAME]"
```

Crea la versione:

gcloud ai-platform versions create $VERSION_NAME \
  --model=$MODEL_NAME \
  --origin=$MODEL_DIR \
  --runtime-version=2.11 \
  --framework=$FRAMEWORK \
  --python-version=3.7 \
  --region=REGION \
  --machine-type=MACHINE_TYPE

Sostituisci quanto segue:

REGION: la regione della regione endpoint su cui hai creato modello. Se hai creato il modello sulla endpoint globale, ometti il flag --region.
MACHINE_TYPE: una macchina type, determinando le risorse di calcolo disponibili per i nodi di previsione.

Per una pipeline scikit-learn con codice (beta), utilizza il componente gcloud beta e assicurati di impostare il valore Flag --package-uris. Per eseguire il deployment del codice personalizzato, il modello deve utilizzare endpoint globale.

gcloud components install beta

gcloud beta ai-platform versions create $VERSION_NAME \
  --model=$MODEL_NAME \
  --origin=$MODEL_DIR \
  --runtime-version=2.11 \
  --framework=$FRAMEWORK \
  --python-version=3.7 \
  --machine-type=mls1-c1-m2 \
  --package-uris=$CUSTOM_CODE_PATH

Per una previsione personalizzata (beta), utilizza gcloud beta, ometti il flag --framework e imposta il Flag per --package-uris e --prediction-class. Per eseguire il deployment di codice personalizzato, il modello deve usare l'endpoint globale.

gcloud components install beta

gcloud beta ai-platform versions create $VERSION_NAME \
  --model=$MODEL_NAME \
  --origin=$MODEL_DIR \
  --runtime-version=2.11 \
  --python-version=3.7 \
  --machine-type=mls1-c1-m2 \
  --package-uris=$CUSTOM_CODE_PATH \
  --prediction-class=$PREDICTOR_CLASS

La creazione della versione richiede alcuni minuti. Una volta pronto, consulta l'output seguente:

Creating version (this might take a few minutes)......done.

Informazioni sulla nuova versione:

gcloud ai-platform versions describe $VERSION_NAME \
  --model=$MODEL_NAME

Dovresti vedere un output simile al seguente:

createTime: '2018-02-28T16:30:45Z'
deploymentUri: gs://your_bucket_name
framework: [YOUR-FRAMEWORK-NAME]
machineType: mls1-c1-m2
name: projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]
pythonVersion: '3.7'
runtimeVersion: '2.11'
state: READY

API REST

Formatta il corpo della richiesta in modo che contenga il oggetto versione. Questo esempio specifica la versione name, deploymentUri, runtimeVersion, framework e machineType. Sostituisci [VALUES_IN_BRACKETS] con i valori appropriati:
```
{
  "name": "[YOUR-VERSION-NAME]",
  "deploymentUri": "gs://your_bucket_name/",
  "runtimeVersion": "2.11",
  "framework": "[YOUR_FRAMEWORK_NAME]",
  "pythonVersion": "3.7",
  "machineType": "[YOUR_MACHINE_TYPE]"
}
```

Effettua la chiamata API REST al seguente percorso, sostituendo [VALUES_IN_BRACKETS] con i valori appropriati:

POST https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions

Sostituisci REGION con la regione della regione endpoint in cui hai creato modello. Se hai creato il modello sulla endpoint globale, usa ml.googleapis.com.

Ad esempio, puoi effettuare la richiesta seguente utilizzando l'curl :

curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "[YOUR-VERSION-NAME]", "deploymentUri": "gs://your_bucket_name/", "runtimeVersion": "2.11", "framework": "[YOUR_FRAMEWORK_NAME]", "pythonVersion": "3.7", "machineType": "[YOUR_MACHINE_TYPE]"}' \
  -H "Authorization: Bearer `gcloud auth print-access-token`" \
  "https://REGION-ml.googleapis.com/v1/projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions"

La creazione della versione richiede alcuni minuti. Una volta pronto, vedi un output simile a questo:

{
  "name": "projects/[YOUR-PROJECT-ID]/operations/create_[YOUR-MODEL-NAME]_[YOUR-VERSION-NAME]-[TIMESTAMP]",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.ml.v1.OperationMetadata",
    "createTime": "2018-07-07T02:51:50Z",
    "operationType": "CREATE_VERSION",
    "modelName": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]",
    "version": {
      "name": "projects/[YOUR-PROJECT-ID]/models/[YOUR-MODEL-NAME]/versions/[YOUR-VERSION-NAME]",
      "deploymentUri": "gs://your_bucket_name",
      "createTime": "2018-07-07T02:51:49Z",
      "runtimeVersion": "2.11",
      "framework": "[YOUR_FRAMEWORK_NAME]",
      "machineType": "[YOUR_MACHINE_TYPE]",
      "pythonVersion": "3.7"
    }
  }
}