Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Utilizzare i modelli in Model Garden

Scopri, testa, ottimizza ed esegui il deployment dei modelli utilizzando Model Garden nella consoleGoogle Cloud . Puoi anche eseguire il deployment dei modelli di Model Garden utilizzando Google Cloud CLI.

Invia prompt di test

Nella console Google Cloud , vai alla pagina Model Garden.

Vai a Model Garden
Trova un modello supportato che vuoi testare e fai clic su Visualizza dettagli.
Fai clic su Apri progettazione prompt.

Viene visualizzata la pagina Progettazione dei prompt.
In Prompt, inserisci il prompt che vuoi testare.
(Facoltativo) Configura i parametri del modello.
Fai clic su Invia.

Ottimizza un modello

Nella console Google Cloud , vai alla pagina Model Garden.

Vai a Model Garden
In Cerca modelli, inserisci Gemma 3, quindi fai clic sulla lente d'ingrandimento per eseguire la ricerca.
Fai clic su Visualizza dettagli nella scheda del modello Gemma 3.
Fai clic su Apri pipeline di ottimizzazione.

Viene visualizzata la pagina Pipeline di Agent Platform.
Per avviare l'ottimizzazione, fai clic su Crea esecuzione.

Ottimizza in un notebook

Le schede dei modelli per la maggior parte dei foundation model open source e dei modelli ottimizzabili supportano l'ottimizzazione in un notebook.

Nella console Google Cloud , vai alla pagina Model Garden.

Vai a Model Garden
Trova un modello supportato che vuoi ottimizzare e vai alla relativa scheda.
Fai clic su Apri notebook.

Esegui il deployment di un modello aperto

Puoi eseguire il deployment di un modello utilizzando la relativa scheda nella console Google Cloud o in modo programmatico.

Per saperne di più sulla configurazione dell'SDK Google Gen AI o di Google Cloud CLI, consulta la panoramica dell'SDK Google Gen AI o Installa Google Cloud CLI.

Console

Nella console Google Cloud , vai alla pagina Model Garden.

Vai a Model Garden
Trova un modello supportato di cui vuoi eseguire il deployment e fai clic sulla relativa scheda.
Fai clic su Esegui il deployment per aprire il riquadro Esegui il deployment del modello.
Nel riquadro Esegui il deployment del modello, specifica i dettagli del deployment.
1. Utilizza o modifica i nomi dei modelli e degli endpoint generati.
2. Seleziona una località in cui creare l'endpoint del modello.
3. Seleziona un tipo di macchina da utilizzare per ogni nodo del deployment.
4. Per utilizzare una prenotazione di Compute Engine, nella sezione Impostazioni di deployment, seleziona Avanzate.
Per il campo Tipo di prenotazione, seleziona un tipo di prenotazione. La prenotazione deve corrispondere alle specifiche della macchina indicate.
- Usa automaticamente la prenotazione creata: Gemini Enterprise Agent Platform seleziona automaticamente una prenotazione consentita con proprietà corrispondenti. Se non c'è capacità nella prenotazione selezionata automaticamente, Gemini Enterprise Agent Platform utilizza il pool di risorse Google Cloud generale.
- Seleziona prenotazioni specifiche: Gemini Enterprise Agent Platform utilizza una prenotazione specifica. Se non c'è capacità per la prenotazione selezionata, viene generato un errore.
- Non utilizzare (valore predefinito): Gemini Enterprise Agent Platform utilizza il pool di risorseGoogle Cloud generale. Questo valore ha lo stesso effetto di non specificare una prenotazione.
Fai clic su Esegui il deployment.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installa l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

Elenca i modelli di cui puoi eseguire il deployment e registra l'ID modello per il deployment. Facoltativamente, puoi elencare i modelli Hugging Face supportati in Model Garden e persino filtrarli in base ai nomi dei modelli. L'output non include modelli ottimizzati.


import vertexai
from vertexai import model_garden

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")

# List deployable models, optionally list Hugging Face models only or filter by model name.
deployable_models = model_garden.list_deployable_models(list_hf_models=False, model_filter="gemma")
print(deployable_models)
# Example response:
# ['google/gemma2@gemma-2-27b','google/gemma2@gemma-2-27b-it', ...]

Visualizza le specifiche di deployment di un modello utilizzando l'ID modello del passaggio precedente. Puoi visualizzare il tipo di macchina, il tipo di acceleratore e l'URI dell'immagine container che Model Garden ha verificato per un determinato modello.


import vertexai
from vertexai import model_garden

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
# model = "google/gemma3@gemma-3-1b-it"
vertexai.init(project=PROJECT_ID, location="us-central1")

# For Hugging Face modelsm the format is the Hugging Face model name, as in
# "meta-llama/Llama-3.3-70B-Instruct".
# Go to https://console.cloud.google.com/vertex-ai/model-garden to find all deployable
# model names.

model = model_garden.OpenModel(model)
deploy_options = model.list_deploy_options()
print(deploy_options)
# Example response:
# [
#   dedicated_resources {
#     machine_spec {
#       machine_type: "g2-standard-12"
#       accelerator_type: NVIDIA_L4
#       accelerator_count: 1
#     }
#   }
#   container_spec {
#     ...
#   }
#   ...
# ]

Esegui il deployment di un modello su un endpoint. Model Garden utilizza la configurazione di deployment predefinita, a meno che non specifichi argomenti e valori aggiuntivi.


import vertexai
from vertexai import model_garden

# TODO(developer): Update and un-comment below lines
# PROJECT_ID = "your-project-id"
vertexai.init(project=PROJECT_ID, location="us-central1")

open_model = model_garden.OpenModel("google/gemma3@gemma-3-12b-it")
endpoint = open_model.deploy(
    machine_type="g2-standard-48",
    accelerator_type="NVIDIA_L4",
    accelerator_count=4,
    accept_eula=True,
)

# Optional. Run predictions on the deployed endoint.
# endpoint.predict(instances=[{"prompt": "What is Generative AI?"}])

REST

Elenca tutti i modelli di cui è possibile eseguire il deployment, quindi recupera l'ID del modello di cui eseguire il deployment. Puoi quindi eseguire il deployment del modello con la configurazione e l'endpoint predefiniti. In alternativa, puoi scegliere di personalizzare il deployment, ad esempio impostando un tipo di macchina specifico o utilizzando un endpoint dedicato.

1. Elenca i modelli di cui puoi eseguire il deployment

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

PROJECT_ID: l'ID progetto Google Cloud .
QUERY_PARAMETERS: Per elencare i modelli di Model Garden, aggiungere i seguenti parametri di ricerca listAllVersions=True&filter=can_deploy(true). Per elencare i modelli Hugging Face, imposta il filtro su alt=json&is_hf_wildcard(true)+AND+labels.VERIFIED_DEPLOYMENT_CONFIG%3DVERIFIED_DEPLOYMENT_SUCCEED&listAllVersions=True.

Metodo HTTP e URL:

GET https://us-central1-aiplatform.googleapis.com/v1/publishers/*/models?QUERY_PARAMETERS

Per inviare la richiesta, scegli una di queste opzioni:

curl

Nota: il seguente comando presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che consente di accedere automaticamente all'interfaccia a riga di comando gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo comando:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: PROJECT_ID" \
     "https://us-central1-aiplatform.googleapis.com/v1/publishers/*/models?QUERY_PARAMETERS"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "PROJECT_ID" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://us-central1-aiplatform.googleapis.com/v1/publishers/*/models?QUERY_PARAMETERS" | Select-Object -Expand Content

Ricevi una risposta JSON simile alla seguente.

{
  "publisherModels": [
    {
      "name": "publishers/google/models/gemma3",
      "versionId": "gemma-3-1b-it",
      "openSourceCategory": "GOOGLE_OWNED_OSS_WITH_GOOGLE_CHECKPOINT",
      "supportedActions": {
        "openNotebook": {
          "references": {
            "us-central1": {
              "uri": "https://colab.research.google.com/github/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/community/model_garden/model_garden_gradio_streaming_chat_completions.ipynb"
            }
          },
          "resourceTitle": "Notebook",
          "resourceUseCase": "Chat Completion Playground",
          "resourceDescription": "Chat with deployed Gemma 2 endpoints via Gradio UI."
        },
        "deploy": {
          "modelDisplayName": "gemma-3-1b-it",
          "containerSpec": {
            "imageUri": "us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250312_0916_RC01",
            "args": [
              "python",
              "-m",
              "vllm.entrypoints.api_server",
              "--host=0.0.0.0",
              "--port=8080",
              "--model=gs://vertex-model-garden-restricted-us/gemma3/gemma-3-1b-it",
              "--tensor-parallel-size=1",
              "--swap-space=16",
              "--gpu-memory-utilization=0.95",
              "--disable-log-stats"
            ],
            "env": [
              {
                "name": "MODEL_ID",
                "value": "google/gemma-3-1b-it"
              },
              {
                "name": "DEPLOY_SOURCE",
                "value": "UI_NATIVE_MODEL"
              }
            ],
            "ports": [
              {
                "containerPort": 8080
              }
            ],
            "predictRoute": "/generate",
            "healthRoute": "/ping"
          },
          "dedicatedResources": {
            "machineSpec": {
              "machineType": "g2-standard-12",
              "acceleratorType": "NVIDIA_L4",
              "acceleratorCount": 1
            }
          },
          "publicArtifactUri": "gs://vertex-model-garden-restricted-us/gemma3/gemma3.tar.gz",
          "deployTaskName": "vLLM 128K context",
          "deployMetadata": {
            "sampleRequest": "{\n    \"instances\": [\n        {\n          \"@requestFormat\": \"chatCompletions\",\n          \"messages\": [\n              {\n                  \"role\": \"user\",\n                  \"content\": \"What is machine learning?\"\n              }\n          ],\n          \"max_tokens\": 100\n        }\n    ]\n}\n"
          }
        },
        ...

2. Esegui il deployment di un modello

Esegui il deployment di un modello da Model Garden o da Hugging Face. Puoi anche personalizzare il deployment specificando campi JSON aggiuntivi.

Esegui il deployment di un modello con la sua configurazione predefinita.

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

LOCATION: una regione in cui è stato eseguito il deployment del modello.
PROJECT_ID: l'ID progetto Google Cloud .
MODEL_ID: l'ID del modello di cui eseguire il deployment, che puoi ottenere elencando tutti i modelli di cui è possibile eseguire il deployment. L'ID utilizza il seguente formato: publishers/PUBLISHER_NAME/models/MODEL_NAME@MODEL_VERSION.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy

Corpo JSON della richiesta:

{
  "publisher_model_name": "MODEL_ID",
  "model_config": {
    "accept_eula": "true"
  }
}

Per inviare la richiesta, scegli una di queste opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

cat > request.json << 'EOF'
{
  "publisher_model_name": "MODEL_ID",
  "model_config": {
    "accept_eula": "true"
  }
}
EOF

Quindi esegui questo comando per inviare la richiesta REST:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy"

PowerShell

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

@'
{
  "publisher_model_name": "MODEL_ID",
  "model_config": {
    "accept_eula": "true"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Quindi esegui questo comando per inviare la richiesta REST:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy" | Select-Object -Expand Content

Ricevi una risposta JSON simile alla seguente.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployOperationMetadata",
    "genericMetadata": {
      "createTime": "2025-03-13T21:44:44.538780Z",
      "updateTime": "2025-03-13T21:44:44.538780Z"
    },
    "publisherModel": "publishers/google/models/gemma3@gemma-3-1b-it",
    "destination": "projects/PROJECT_ID/locations/LOCATION",
    "projectNumber": "PROJECT_ID"
  }
}

Esegui il deployment di un modello Hugging Face

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

LOCATION: una regione in cui è stato eseguito il deployment del modello.
PROJECT_ID: l'ID progetto Google Cloud .
MODEL_ID: l'ID modello Hugging Face di cui eseguire il deployment, che puoi ottenere elencando tutti i modelli di cui è possibile eseguire il deployment. L'ID utilizza il seguente formato: PUBLISHER_NAME/MODEL_NAME.
ACCESS_TOKEN: se il modello è protetto, fornisci un token di accesso.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy

Corpo JSON della richiesta:

{
  "hugging_face_model_id": "MODEL_ID",
  "hugging_face_access_token": "ACCESS_TOKEN",
  "model_config": {
    "accept_eula": "true"
  }
}

Per inviare la richiesta, scegli una di queste opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

cat > request.json << 'EOF'
{
  "hugging_face_model_id": "MODEL_ID",
  "hugging_face_access_token": "ACCESS_TOKEN",
  "model_config": {
    "accept_eula": "true"
  }
}
EOF

Quindi esegui questo comando per inviare la richiesta REST:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy"

PowerShell

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

@'
{
  "hugging_face_model_id": "MODEL_ID",
  "hugging_face_access_token": "ACCESS_TOKEN",
  "model_config": {
    "accept_eula": "true"
  }
}
'@  | Out-File -FilePath request.json -Encoding utf8

Quindi esegui questo comando per inviare la richiesta REST:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy" | Select-Object -Expand Content

Ricevi una risposta JSON simile alla seguente.

{
  "name": "projects/PROJECT_ID/locations/us-central1LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployOperationMetadata",
    "genericMetadata": {
      "createTime": "2025-03-13T21:44:44.538780Z",
      "updateTime": "2025-03-13T21:44:44.538780Z"
    },
    "publisherModel": "publishers/PUBLISHER_NAME/model/MODEL_NAME",
    "destination": "projects/PROJECT_ID/locations/LOCATION",
    "projectNumber": "PROJECT_ID"
  }
}

Esegui il deployment di un modello con personalizzazioni

Prima di utilizzare i dati della richiesta, apporta le sostituzioni seguenti:

LOCATION: una regione in cui è stato eseguito il deployment del modello.
PROJECT_ID: l'ID progetto Google Cloud .
MODEL_ID: l'ID del modello di cui eseguire il deployment, che puoi ottenere elencando tutti i modelli di cui è possibile eseguire il deployment. L'ID utilizza il seguente formato: publishers/PUBLISHER_NAME/models/MODEL_NAME@MODEL_VERSION, ad esempio google/gemma@gemma-2b o stabilityai/stable-diffusion-xl-base-1.0.
MACHINE_TYPE: definisce l'insieme di risorse da eseguire il deployment per il modello, ad esempio g2-standard-4.
ACCELERATOR_TYPE: specifica gli acceleratori da aggiungere al deployment per migliorare le prestazioni quando si lavora con workload intensivi, ad esempio NVIDIA_L4
ACCELERATOR_COUNT: il numero di acceleratori da utilizzare nel deployment.
reservation_affinity_type: per utilizzare una prenotazione Compute Engine esistente per il deployment, specifica una prenotazione qualsiasi o una specifica. Se specifichi questo valore, non specificare spot.
spot: indica se utilizzare VM spot per il deployment.
IMAGE_URI: la posizione dell'immagine container da utilizzare, ad esempio us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241016_0916_RC00_maas
CONTAINER_ARGS: argomenti da passare al container durante il deployment.
CONTAINER_PORT: un numero di porta per il container.
fast_tryout_enabled: quando testi un modello, puoi scegliere di utilizzare un deployment più rapido. Questa opzione è disponibile solo per i modelli molto utilizzati con determinati tipi di macchine. Se abilitata, non puoi specificare le configurazioni del modello o del deployment.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy

Corpo JSON della richiesta:

{
  "publisher_model_name": "MODEL_ID",
  "deploy_config": {
    "dedicated_resources": {
      "machine_spec": {
        "machine_type": "MACHINE_TYPE",
        "accelerator_type": "ACCELERATOR_TYPE",
        "accelerator_count": ACCELERATOR_COUNT,
        "reservation_affinity": {
          "reservation_affinity_type": "ANY_RESERVATION"
        }
      },
      "spot": "false"
    }
  },
  "model_config": {
    "accept_eula": "true",
    "container_spec": {
      "image_uri": "IMAGE_URI",
      "args": [CONTAINER_ARGS ],
      "ports": [
        {
          "container_port": CONTAINER_PORT
        }
      ]
    }
  },
  "deploy_config": {
    "fast_tryout_enabled": false
  },
}

Per inviare la richiesta, scegli una di queste opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

cat > request.json << 'EOF'
{
  "publisher_model_name": "MODEL_ID",
  "deploy_config": {
    "dedicated_resources": {
      "machine_spec": {
        "machine_type": "MACHINE_TYPE",
        "accelerator_type": "ACCELERATOR_TYPE",
        "accelerator_count": ACCELERATOR_COUNT,
        "reservation_affinity": {
          "reservation_affinity_type": "ANY_RESERVATION"
        }
      },
      "spot": "false"
    }
  },
  "model_config": {
    "accept_eula": "true",
    "container_spec": {
      "image_uri": "IMAGE_URI",
      "args": [CONTAINER_ARGS ],
      "ports": [
        {
          "container_port": CONTAINER_PORT
        }
      ]
    }
  },
  "deploy_config": {
    "fast_tryout_enabled": false
  },
}
EOF

Quindi esegui questo comando per inviare la richiesta REST:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy"

PowerShell

Salva il corpo della richiesta in un file denominato request.json. Esegui questo comando nel terminale per creare o sovrascrivere questo file nella directory corrente:

@'
{
  "publisher_model_name": "MODEL_ID",
  "deploy_config": {
    "dedicated_resources": {
      "machine_spec": {
        "machine_type": "MACHINE_TYPE",
        "accelerator_type": "ACCELERATOR_TYPE",
        "accelerator_count": ACCELERATOR_COUNT,
        "reservation_affinity": {
          "reservation_affinity_type": "ANY_RESERVATION"
        }
      },
      "spot": "false"
    }
  },
  "model_config": {
    "accept_eula": "true",
    "container_spec": {
      "image_uri": "IMAGE_URI",
      "args": [CONTAINER_ARGS ],
      "ports": [
        {
          "container_port": CONTAINER_PORT
        }
      ]
    }
  },
  "deploy_config": {
    "fast_tryout_enabled": false
  },
}
'@  | Out-File -FilePath request.json -Encoding utf8

Quindi esegui questo comando per inviare la richiesta REST:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION:deploy" | Select-Object -Expand Content

Ricevi una risposta JSON simile alla seguente.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployOperationMetadata",
    "genericMetadata": {
      "createTime": "2025-03-13T21:44:44.538780Z",
      "updateTime": "2025-03-13T21:44:44.538780Z"
    },
    "publisherModel": "publishers/google/models/gemma3@gemma-3-1b-it",
    "destination": "projects/PROJECT_ID/locations/LOCATION",
    "projectNumber": "PROJECT_ID"
  }
}

gcloud

Prima di iniziare, specifica un progetto di quota per eseguire i seguenti comandi. I comandi che esegui vengono conteggiati in base alle quote per quel progetto. Per saperne di più, consulta Imposta il progetto di quota.

Elenca i modelli di cui puoi eseguire il deployment eseguendo il comando gcloud ai model-garden models list. Questo comando elenca tutti gli ID modello e quelli di cui puoi eseguire il deployment autonomamente.

gcloud ai model-garden models list

Nell'output, trova l'ID del modello di cui eseguire il deployment. L'esempio seguente mostra un output abbreviato.

MODEL_ID                                      CAN_DEPLOY  CAN_PREDICT
google/gemma2@gemma-2-27b                     Yes         No
google/gemma2@gemma-2-27b-it                  Yes         No
google/gemma2@gemma-2-2b                      Yes         No
google/gemma2@gemma-2-2b-it                   Yes         No
google/gemma2@gemma-2-9b                      Yes         No
google/gemma2@gemma-2-9b-it                   Yes         No
google/gemma3@gemma-3-12b-it                  Yes         No
google/gemma3@gemma-3-12b-pt                  Yes         No
google/gemma3@gemma-3-1b-it                   Yes         No
google/gemma3@gemma-3-1b-pt                   Yes         No
google/gemma3@gemma-3-27b-it                  Yes         No
google/gemma3@gemma-3-27b-pt                  Yes         No
google/gemma3@gemma-3-4b-it                   Yes         No
google/gemma3@gemma-3-4b-pt                   Yes         No
google/gemma3n@gemma-3n-e2b                   Yes         No
google/gemma3n@gemma-3n-e2b-it                Yes         No
google/gemma3n@gemma-3n-e4b                   Yes         No
google/gemma3n@gemma-3n-e4b-it                Yes         No
google/gemma@gemma-1.1-2b-it                  Yes         No
google/gemma@gemma-1.1-2b-it-gg-hf            Yes         No
google/gemma@gemma-1.1-7b-it                  Yes         No
google/gemma@gemma-1.1-7b-it-gg-hf            Yes         No
google/gemma@gemma-2b                         Yes         No
google/gemma@gemma-2b-gg-hf                   Yes         No
google/gemma@gemma-2b-it                      Yes         No
google/gemma@gemma-2b-it-gg-hf                Yes         No
google/gemma@gemma-7b                         Yes         No
google/gemma@gemma-7b-gg-hf                   Yes         No
google/gemma@gemma-7b-it                      Yes         No
google/gemma@gemma-7b-it-gg-hf                Yes         No

L'output non include modelli ottimizzati o modelli Hugging Face. Per visualizzare i modelli Hugging Face supportati, aggiungi il flag --can-deploy-hugging-face-models.

Per visualizzare le specifiche del deployment di un modello, esegui il comando gcloud ai model-garden models list-deployment-config. Puoi visualizzare il tipo di macchina, il tipo di acceleratore e l'URI dell'immagine container supportati da Model Garden per un determinato modello.
```
gcloud ai model-garden models list-deployment-config \
    --model=MODEL_ID
```
Sostituisci MODEL_ID con l'ID modello del comando list precedente, ad esempio google/gemma@gemma-2b o stabilityai/stable-diffusion-xl-base-1.0.
Esegui il deployment di un modello su un endpoint eseguendo il comando gcloud ai model-garden models deploy. Model Garden genera un nome visualizzato per l'endpoint e utilizza la configurazione di deployment predefinita, a meno che non specifichi argomenti e valori aggiuntivi.

Per eseguire il comando in modo asincrono, includi il flag --asynchronous.
```
gcloud ai model-garden models deploy \
    --model=MODEL_ID \
    [--machine-type=MACHINE_TYPE] \
    [--accelerator-type=ACCELERATOR_TYPE] \
    [--endpoint-display-name=ENDPOINT_NAME] \
    [--hugging-face-access-token=HF_ACCESS_TOKEN] \
    [--reservation-affinity reservation-affinity-type=any-reservation] \
    [--reservation-affinity reservation-affinity-type=specific-reservation, key="compute.googleapis.com/reservation-name", values=RESERVATION_RESOURCE_NAME] \
    [--asynchronous]
```
Sostituisci i seguenti segnaposto:
- MODEL_ID: l'ID del modello ottenuto dal comando list precedente. Per i modelli Hugging Face, utilizza il formato dell'URL del modello Hugging Face, ad esempio stabilityai/stable-diffusion-xl-base-1.0.
- MACHINE_TYPE: definisce l'insieme di risorse di cui eseguire il deployment per il tuo modello, ad esempio g2-standard-4.
- ACCELERATOR_TYPE: specifica gli acceleratori da aggiungere al tuo deployment per migliorare le prestazioni quando lavori con workload intensivi, ad esempio NVIDIA_L4.
- ENDPOINT_NAME: un nome per l'endpoint Gemini Enterprise Agent Platform di cui è stato eseguito il deployment.
- HF_ACCESS_TOKEN: per i modelli Hugging Face, se il modello è protetto, fornisci un token di accesso.
- RESERVATION_RESOURCE_NAME: per utilizzare una prenotazione di Compute Engine specifica, indica il nome della prenotazione. Se specifichi una prenotazione specifica, non puoi specificare any-reservation.
L'output include la configurazione del deployment utilizzata da Model Garden, l'ID endpoint e l'ID operazione di deployment, che puoi utilizzare per controllare lo stato del deployment.
```
Using the default deployment configuration:
 Machine type: g2-standard-12
 Accelerator type: NVIDIA_L4
 Accelerator count: 1

The project has enough quota. The current usage of quota for accelerator type NVIDIA_L4 in region us-central1 is 0 out of 28.

Deploying the model to the endpoint. To check the deployment status, you can try one of the following methods:
1) Look for endpoint `ENDPOINT_DISPLAY_NAME` at the [Agent Platform] -> [Online prediction] tab in Cloud Console
2) Use `gcloud ai operations describe OPERATION_ID --region=LOCATION` to find the status of the deployment long-running operation
```
Per visualizzare i dettagli del deployment, esegui il comando gcloud ai endpoints list --list-model-garden-endpoints-only:
```
gcloud ai endpoints list --list-model-garden-endpoints-only \
    --region=LOCATION_ID
```
Sostituisci LOCATION_ID con la regione in cui hai eseguito il deployment del modello.

L'output include tutti gli endpoint creati da Model Garden e informazioni come l'ID endpoint, il nome dell'endpoint e se l'endpoint è associato a un modello di cui è stato eseguito il deployment. Per trovare il deployment, cerca il nome dell'endpoint restituito dal comando precedente.

Terraform

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base. Per saperne di più, consulta la documentazione di riferimento del fornitore Terraform.

Esegui il deployment di un modello

L'esempio seguente esegue il deployment del modello gemma-3-1b-it in un nuovo endpoint Agent Platform in us-central1 utilizzando le configurazioni predefinite.

terraform {
  required_providers {
    google = {
      source = "hashicorp/google"
      version = "6.45.0"
    }
  }
}

provider "google" {
  region  = "us-central1"
}

resource "google_vertex_ai_endpoint_with_model_garden_deployment" "gemma_deployment" {
  publisher_model_name = "publishers/google/models/gemma3@gemma-3-1b-it"
  location = "us-central1"
  model_config {
    accept_eula = True
  }
}

Per eseguire il deployment di un modello con personalizzazione, consulta Endpoint Agent Platform con deployment di Model Garden per i dettagli.

Applica la configurazione

terraform init
terraform plan
terraform apply

Dopo aver applicato la configurazione, Terraform esegue il provisioning di un nuovo endpoint Agent Platform ed esegue il deployment del modello aperto specificato.

Elimina

Per eliminare l'endpoint e il deployment del modello, esegui questo comando:

terraform destroy

Esegui il deployment di un modello partner e invia richieste di previsione

Nella console Google Cloud , vai alla pagina Model Garden e utilizza il filtro Raccolte di modelli per visualizzare i Modelli partner con deployment autonomo. Scegli dall'elenco dei modelli di partner con deployment autonomo e acquista il modello facendo clic su Abilita.

Devi eseguire il deployment sui tipi di macchine richiesti dal partner, come descritto nella sezione "Configurazione hardware consigliata" della scheda del modello Model Garden. Una volta eseguito il deployment, le risorse di erogazione del modello si trovano in un progetto sicuro gestito da Google.

Console

Nella console Google Cloud , vai alla pagina Model Garden.

Vai a Model Garden
Per trovare un modello specifico, inserisci il suo nome nella casella di ricerca di Model Garden.
Per visualizzare tutti i modelli di cui puoi eseguire il deployment autonomo, nella sezione Raccolte di modelli del riquadro dei filtri, seleziona Modelli di partner con deployment autonomo. L'elenco risultante include tutti i modelli dei partner di cui è possibile eseguire il deployment autonomamente.
Fai clic sul nome del modello di cui eseguire il deployment per aprire la relativa scheda.
Fai clic su Opzioni di deployment.
Nel riquadro Esegui il deployment su Agent Platform, configura il deployment, ad esempio la località e il tipo di macchina.
Fai clic su Esegui il deployment.

Al termine del deployment, puoi richiedere previsioni utilizzando l'SDK o l'API. Ulteriori istruzioni sono disponibili nella sezione "Documentazione" della scheda del modello.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installa l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

Deployment del modello con un clic

Puoi eseguire il deployment autonomo di un modello partner con un solo clic.

Visualizza le specifiche di deployment di un modello utilizzando l'ID modello del passaggio precedente. Puoi visualizzare il tipo di macchina, il tipo di acceleratore e l'URI dell'immagine container che Model Garden ha verificato per un determinato modello.
```
import vertexai
from vertexai import model_garden

vertexai.init(project=PROJECT_ID, location="us-central1")

model = model_garden.PartnerModel(model)
deploy_options = model.list_deploy_options()
print(deploy_options)
```

Esegui il deployment di un modello con un solo clic.

from vertexai import model_garden

# Deploy model
model = model_garden.PartnerModel(f"{PUBLISHER}/{MODEL}@{VERSION}")

endpoint = model.deploy(
    machine_type=MACHINE_TYPE,
    accelerator_type=ACCELERATOR_TYPE,
    accelerator_count=ACCELERATOR_COUNT,
    min_replica_count=1,
    max_replica_count=1,
)

Deployment in più passaggi

Puoi anche caricare un modello partner, creare un endpoint ed eseguire manualmente il deployment del modello.

Nel codice, sostituisci i seguenti segnaposto:

LOCATION: la regione in cui prevedi di eseguire il deployment del modello e dell'endpoint.
PROJECT_ID: il tuo ID progetto.
DISPLAY_NAME: un nome descrittivo per la risorsa associata.
PUBLISHER_NAME: il nome del partner che fornisce il modello da caricare o di cui eseguire il deployment.
PUBLISHER_MODEL_NAME: il nome del modello da caricare.
MACHINE_TYPE: definisce l'insieme di risorse di cui eseguire il deployment per il tuo modello, ad esempio g2-standard-4. Devi corrispondere a una delle configurazioni fornite dal partner.
ACCELERATOR_TYPE: specifica gli acceleratori da aggiungere al tuo deployment per migliorare le prestazioni quando lavori con workload intensivi, ad esempio NVIDIA_L4. Devi corrispondere a una delle configurazioni fornite dal partner.
ACCELERATOR_COUNT: il numero di acceleratori da utilizzare. Devi corrispondere a una delle configurazioni fornite dal partner.
REQUEST_PAYLOAD: i campi e i valori da includere nella richiesta di previsione. Visualizza la scheda del modello di Model Garden del partner per vedere i campi disponibili.

from google.cloud import aiplatform

aiplatform.init(project=PROJECT_ID, location=LOCATION)

# Upload a model
model = aiplatform.Model.upload(
    display_name="DISPLAY_NAME_MODEL",
    model_garden_source_model_name = f"publishers/PUBLISHER_NAME/models/PUBLISHER_MODEL_NAME",
)

# Create endpoint
my_endpoint = aiplatform.Endpoint.create(display_name="DISPLAY_NAME_ENDPOINT")

# Deploy model
MACHINE_TYPE = "MACHINE_TYPE"  # @param {type: "string"}
ACCELERATOR_TYPE = "ACCELERATOR_TYPE" # @param {type: "string"}
ACCELERATOR_COUNT = ACCELERATOR_COUNT # @param {type: "number"}

model.deploy(
    endpoint=my_endpoint,
    deployed_model_display_name="DISPLAY_NAME_DEPLOYED_MODEL",
    traffic_split={"0": 100},
    machine_type=MACHINE_TYPE,
    accelerator_type=ACCELERATOR_TYPE,
    accelerator_count=ACCELERATOR_COUNT,
    min_replica_count=1,
    max_replica_count=1,
)

# Unary call for predictions
PAYLOAD = {
    REQUEST_PAYLOAD
}

request = json.dumps(PAYLOAD)

response = my_endpoint.raw_predict(
    body = request,
    headers = {'Content-Type':'application/json'}
)

print(response)

# Streaming call for predictions
PAYLOAD = {
    REQUEST_PAYLOAD
}

request = json.dumps(PAYLOAD)

for stream_response in my_endpoint.stream_raw_predict(
    body = request,
    headers = {'Content-Type':'application/json'}
):
    print(stream_response)

REST

Nei comandi curl di esempio, sostituisci i seguenti segnaposto:

LOCATION: la regione in cui prevedi di eseguire il deployment del modello e dell'endpoint.
PROJECT_ID: il tuo ID progetto.
DISPLAY_NAME: un nome descrittivo per la risorsa associata.
PUBLISHER_NAME: il nome del partner che fornisce il modello da caricare o di cui eseguire il deployment.
PUBLISHER_MODEL_NAME: il nome del modello da caricare.
ENDPOINT_ID: l'ID dell'endpoint.
MACHINE_TYPE: definisce l'insieme di risorse di cui eseguire il deployment per il tuo modello, ad esempio g2-standard-4. Devi corrispondere a una delle configurazioni fornite dal partner.
ACCELERATOR_TYPE: specifica gli acceleratori da aggiungere al tuo deployment per migliorare le prestazioni quando lavori con workload intensivi, ad esempio NVIDIA_L4. Devi corrispondere a una delle configurazioni fornite dal partner.
ACCELERATOR_COUNT: il numero di acceleratori da utilizzare. Devi corrispondere a una delle configurazioni fornite dal partner.
REQUEST_PAYLOAD: i campi e i valori da includere nella richiesta di previsione. Visualizza la scheda del modello di Model Garden del partner per vedere i campi disponibili.

Carica un modello per aggiungerlo al tuo Model Registry.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://LOCATION-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION/models:upload \
-d '{
"model": {
  "displayName": "DISPLAY_NAME_MODEL",
  "baseModelSource": {
    "modelGardenSource": {
      "publicModelName": f"publishers/PUBLISHER_NAME/models/PUBLISHER_MODEL_NAME",
    }
  }
}
}'

Crea un endpoint.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints \
-d '{
"displayName": "DISPLAY_NAME_ENDPOINT"
}'

Esegui il deployment del modello caricato sull'endpoint.

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:deployModel \
-d '{
"deployedModel": {
  "model": f"projects/PROJECT_ID/locations/LOCATION/models/MODEL_ID",
  "displayName": "DISPLAY_NAME_DEPLOYED_MODEL",
  "dedicatedResources": {
   "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorType": "ACCELERATOR_TYPE",
      "acceleratorCount":"ACCELERATOR_COUNT",
   },
   "minReplicaCount": 1,
   "maxReplicaCount": 1
  },
},
"trafficSplit": {
  "0": 100
}
}'

Dopo aver eseguito il deployment del modello, puoi effettuare una chiamata unaria o in streaming per le previsioni. Visualizza la scheda del modello di Model Garden del partner per vedere quali metodi API sono supportati.

Esempio di chiamata unaria:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:rawPredict \
-d 'REQUEST_PAYLOAD'

Esempio di chiamata in streaming:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID:streamRawPredict \
-d 'REQUEST_PAYLOAD'

Esegui il deployment di un modello in un endpoint privato

Puoi eseguire il deployment dei modelli di Model Garden in un endpoint Private Service Connect (PSC) per creare una connessione sicura e privata al tuo modello. Questa configurazione può anche essere integrata con un bilanciatore del carico delle applicazioni regionale interno ed esterno quando viene eseguito il deployment con un gruppo di endpoint di rete PSC. Segui i passaggi riportati di seguito per configurare un endpoint PSC per il tuo modello, garantendo la connettività privata.

Nella console Google Cloud , vai alla pagina Model Garden.

Vai a Model Garden
Trova un modello di cui eseguire il deployment e fai clic sulla relativa scheda.
Fai clic su Esegui il deployment del modello. Nel riquadro Esegui il deployment del modello, le impostazioni di deployment predefinite si basano su un endpoint pubblico dedicato.
Seleziona Modifica impostazione per attivare ulteriori opzioni di deployment, tra cui l'accesso privato.
Configura le impostazioni di deployment.
- Seleziona una località in cui creare l'endpoint del modello.
- Accetta o modifica il nome del modello e dell'endpoint generati.
- La selezione di un tipo di macchina per il deployment è facoltativa, poiché la configurazione consigliata è stata preselezionata per te.
- Per il campo Tipo di prenotazione, seleziona un tipo di prenotazione. La prenotazione deve corrispondere alle specifiche della macchina indicate.
  - Usa automaticamente la prenotazione creata: Gemini Enterprise Agent Platform seleziona una prenotazione disponibile con proprietà corrispondenti. Se non è disponibile capacità nella prenotazione selezionata, Gemini Enterprise Agent Platform utilizza il pool di risorse generali Google Cloud .
  - Seleziona prenotazioni specifiche: Gemini Enterprise Agent Platform utilizza una prenotazione specifica. Se nella prenotazione selezionata non è disponibile capacità, il deployment non riesce.
  - Nessuna prenotazione (valore predefinito): Gemini Enterprise Agent Platform utilizza il pool di risorseGoogle Cloud generale.
- Configura le policy di disponibilità.
  - Standard: ideale per la maggior parte dei workload.
  - Spot: ideale per workload a tolleranza di errore.
  - Flex Start: utilizza Dynamic Workload Scheduler (DWS) per gestire e assegnare priorità alle richieste di allocazione delle risorse
Configura l'accesso agli endpoint per il networking privato.
- Seleziona Privato (Private Service Connect).
- Seleziona ID progetto. Per concedere l'accesso ad altri progetti, inserisci qui i relativi ID progetto. Se lasci vuoto questo campo, l'endpoint sarà accessibile solo dall'interno del progetto corrente.
Fai clic su Esegui il deployment.
Per visualizzare il deployment, vai alla pagina Model Garden e seleziona Visualizza i miei endpoint e i miei modelli per visualizzarlo nella sezione I miei endpoint. Assicurati di aver selezionato la regione corretta per garantire che l'endpoint sia visibile. Seleziona l'endpoint. Lo stato verrà visualizzato come In fase di deployment e cambierà in Pronto una volta completato.

Ottieni l'ID endpoint, quindi apri Cloud Shell ed esegui i passaggi seguenti per ottenere l'URI del collegamento di servizio privato:

gcloud ai endpoints describe ENDPOINT_ID --region=REGION  | grep -i serviceAttachment:

Di seguito è riportato un esempio:

user@cloudshell:$ gcloud ai endpoints describe 2124795225560842240 --region=europe-west4 | grep -i serviceAttachment:
Using endpoint [https://europe-west4-aiplatform.googleapis.com/]
    serviceAttachment: projects/o9457b320a852208e-tp/regions/europe-west4/serviceAttachments/gkedpm-52065579567eaf39bfe24f25f7981d

Dopo aver ottenuto il collegamento al servizio, hai le seguenti opzioni per accedere al modello:

Esegui il deployment di un endpoint PSC nello stesso VPC del progetto concesso. Questo approccio consente la raggiungibilità tramite networking ibrido e all'interno dello stesso VPC. È importante notare che gli endpoint PSC non sono raggiungibili tramite il peering VPC.
Esegui il deployment di un gruppo di endpoint di rete (NEG) Private Service Connect (PSC), puoi farlo all'interno dello stesso VPC del progetto consentito. In questo modo puoi esporre il modello tramite un bilanciatore del carico interno o esterno, il che offre diversi vantaggi:
- Accesso tramite peering VPC: è possibile accedere al bilanciatore del carico tramite reti VPC in peering.
- Funzionalità di sicurezza: ricevi assistenza per Cloud Armor e Model Armor per proteggere l'endpoint.
- Gestione del traffico: consente il routing avanzato del traffico, ad esempio la riscrittura di host e percorsi.
- Accesso centralizzato: è possibile utilizzare un singolo bilanciatore del carico delle applicazioni per instradare il traffico al modello utilizzando le regole di percorso.

Visualizza o gestisci un endpoint

Per visualizzare e gestire l'endpoint, vai alla pagina Previsione online di Agent Platform.

Vai alla previsione online

Agent Platform elenca tutti gli endpoint del tuo progetto per una determinata regione. Fai clic su un endpoint per visualizzarne i dettagli, ad esempio i modelli di cui è stato eseguito il deployment nell'endpoint.

Annulla il deployment dei modelli ed elimina le risorse

Per impedire a un modello di cui è stato eseguito il deployment di utilizzare le risorse del tuo progetto, annulla il deployment del modello dal relativo endpoint. Devi annullare il deployment di un modello prima di poter eliminare l'endpoint e il modello.

Annullamento deployment modelli

Annulla il deployment di un modello dal relativo endpoint.

Console

Nella console Google Cloud , vai alla scheda Endpoint nella pagina Previsione online.

Vai a Endpoint
Nell'elenco a discesa Regione, scegli la regione in cui si trova l'endpoint.
Fai clic sul nome dell'endpoint per aprire la pagina dei dettagli.
Nella riga del modello, fai clic su Azioni e poi seleziona Annulla il deployment del modello nell'endpoint.
Nella finestra di dialogo Annulla il deployment del modello nell'endpoint, fai clic su Annulla il deployment.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installa l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

Nel codice, sostituisci:

PROJECT_ID con l'ID progetto
LOCATION con la tua regione, ad esempio "us-central1"
ENDPOINT_ID con l'ID endpoint

from google.cloud import aiplatform

aiplatform.init(project=PROJECT_ID, location=LOCATION)

# To find out which endpoints are available, un-comment the line below:
# endpoints = aiplatform.Endpoint.list()

endpoint = aiplatform.Endpoint(ENDPOINT_ID)
endpoint.undeploy_all()

gcloud

In questi comandi, sostituisci:

PROJECT_ID con il nome del tuo progetto
LOCATION_ID con la regione in cui hai eseguito il deployment del modello e dell'endpoint
ENDPOINT_ID con l'ID endpoint
MODEL_ID con l'ID modello del comando list model
DEPLOYED_MODEL_ID con l'ID del modello di cui è stato eseguito il deployment

Trova l'ID endpoint associato al tuo deployment eseguendo il comando gcloud ai endpoints list.

gcloud ai endpoints list \
    --project=PROJECT_ID \
    --region=LOCATION_ID

Trova l'ID modello eseguendo il comando gcloud ai models list.

gcloud ai models list \
    --project=PROJECT_ID \
    --region=LOCATION_ID

Utilizza l'ID modello del comando precedente per ottenere l'ID modello di cui è stato eseguito il deployment eseguendo il comando gcloud ai models describe.

gcloud ai models describe MODEL_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID

L'output abbreviato è simile all'esempio seguente. Nell'output, l'ID è denominato deployedModelId.

Using endpoint [https://us-central1-aiplatform.googleapis.com/]
artifactUri: [URI removed]
baseModelSource:
  modelGardenSource:
    publicModelName: publishers/google/models/gemma2
...
deployedModels:
-   deployedModelId: '1234567891234567891'
  endpoint: projects/12345678912/locations/us-central1/endpoints/12345678912345
displayName: gemma2-2b-it-12345678912345
etag: [ETag removed]
modelSourceInfo:
  sourceType: MODEL_GARDEN
name: projects/123456789123/locations/us-central1/models/gemma2-2b-it-12345678912345
...

Esegui il comando gcloud ai endpoints undeploy-model per annullare il deployment del modello dall'endpoint utilizzando l'ID endpoint e l'ID modello di cui è stato eseguito il deployment dei comandi precedenti.
```
gcloud ai endpoints undeploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID \
    --deployed-model-id=DEPLOYED_MODEL_ID
```
Questo comando non produce alcun output.

Eliminazione endpoint

Elimina l'endpoint di Gemini Enterprise Agent Platform associato al deployment del modello.

Console

Nella console Google Cloud , vai alla scheda Endpoint nella pagina Previsione online.

Vai a Endpoint
Nell'elenco a discesa Regione, scegli la regione in cui si trova l'endpoint.
Alla fine della riga dell'endpoint, fai clic su Azioni, quindi seleziona Elimina endpoint.
Nel prompt di conferma, fai clic su Conferma.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installa l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

Nel codice, sostituisci:

PROJECT_ID con l'ID progetto
LOCATION con la tua regione, ad esempio "us-central1"
ENDPOINT_ID con l'ID endpoint

from google.cloud import aiplatform

aiplatform.init(project=PROJECT_ID, location=LOCATION)

# To find out which endpoints are available, un-comment the line below:
# endpoints = aiplatform.Endpoint.list()

endpoint = aiplatform.Endpoint(ENDPOINT_ID)
endpoint.delete()

gcloud

In questi comandi, sostituisci:

PROJECT_ID con il nome del tuo progetto
LOCATION_ID con la regione in cui hai eseguito il deployment del modello e dell'endpoint
ENDPOINT_ID con l'ID endpoint

Recupera l'ID endpoint da eliminare eseguendo il comando gcloud ai endpoints list. Questo comando elenca gli ID endpoint di tutti gli endpoint del progetto.
```
gcloud ai endpoints list \
    --project=PROJECT_ID \
    --region=LOCATION_ID
```
Esegui il comando gcloud ai endpoints delete per eliminare l'endpoint.
```
gcloud ai endpoints delete ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID
```
Quando richiesto, digita y per confermare. Questo comando non produce alcun output.

Eliminazione modelli

Elimina la risorsa del modello associata al deployment del modello.

Console

Vai alla pagina Model Registry dalla sezione Agent Platform nella console Google Cloud .

Vai alla pagina Model Registry
Nell'elenco a discesa Regione, scegli la regione in cui hai eseguito il deployment del modello.
Nella riga del modello, fai clic su Azioni e poi seleziona Elimina modello.

Quando elimini il modello, tutte le versioni e le valutazioni associate vengono eliminate dal tuo progetto Google Cloud .
Nel prompt di conferma, fai clic su Elimina.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installa l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

Nel codice, sostituisci:

PROJECT_ID con l'ID progetto
LOCATION con la tua regione, ad esempio "us-central1"
MODEL_ID con l'ID del tuo modello

from google.cloud import aiplatform

aiplatform.init(project=PROJECT_ID, location=LOCATION)

# To find out which models are available in Model Registry, un-comment the line below:
# models = aiplatform.Model.list()

model = aiplatform.Model(MODEL_ID)
model.delete()

gcloud

In questi comandi, sostituisci:

PROJECT_ID con il nome del tuo progetto
LOCATION_ID con la regione in cui hai eseguito il deployment del modello e dell'endpoint
MODEL_ID con l'ID modello del comando list model

Trova l'ID modello da eliminare eseguendo il comando gcloud ai models list.

gcloud ai models list \
    --project=PROJECT_ID \
    --region=LOCATION_ID

Esegui il comando gcloud ai models delete per eliminare il modello fornendo l'ID e la località del modello.
```
gcloud ai models delete MODEL_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID
```

Visualizza esempi di codice

La maggior parte delle schede dei modelli per le soluzioni specifiche per le attività contiene esempi di codice che puoi copiare e testare.

Nella console Google Cloud , vai alla pagina Model Garden.

Vai a Model Garden
Trova un modello supportato per cui vuoi visualizzare gli esempi di codice e fai clic sulla scheda Documentazione.
La pagina scorre fino alla sezione della documentazione con il codice campione incorporato.

Crea un'app di visione

Le schede dei modelli di visione artificiale applicabili supportano la creazione di un'applicazione di visione artificiale.

Nella console Google Cloud , vai alla pagina Model Garden.

Vai a Model Garden
Nella sezione Soluzioni specifiche per le attività, trova un modello di visione che vuoi utilizzare per creare un'applicazione di visione e fai clic su Visualizza dettagli.
Fai clic su Crea app.

Viene visualizzata la pagina di Vertex AI Vision.
In Nome applicazione, inserisci un nome per l'applicazione e fai clic su Continua.
Seleziona un piano di fatturazione e fai clic su Crea.

Viene visualizzato Vertex AI Vision Studio, dove puoi continuare a creare la tua applicazione di visione artificiale.

Utilizzare i modelli in Model Garden Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Invia prompt di test

Ottimizza un modello

Ottimizza in un notebook

Esegui il deployment di un modello aperto

Console

Python

REST

1. Elenca i modelli di cui puoi eseguire il deployment

curl

PowerShell

2. Esegui il deployment di un modello

Esegui il deployment di un modello con la sua configurazione predefinita.

curl

PowerShell

Esegui il deployment di un modello Hugging Face

curl

PowerShell

Esegui il deployment di un modello con personalizzazioni

curl

PowerShell

gcloud

Terraform

Esegui il deployment di un modello

Applica la configurazione

Elimina

Esegui il deployment di un modello partner e invia richieste di previsione

Console

Python

Deployment del modello con un clic

Deployment in più passaggi

REST

Esegui il deployment di un modello in un endpoint privato

Visualizza o gestisci un endpoint

Annulla il deployment dei modelli ed elimina le risorse

Annullamento deployment modelli

Console

Python

gcloud

Eliminazione endpoint

Console

Python

gcloud

Eliminazione modelli

Console

Python

gcloud

Visualizza esempi di codice

Crea un'app di visione

Utilizzare i modelli in Model Garden