Usar modelos no Model Garden

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

SDK da Vertex AI para Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Saiba mais na documentação de referência da API SDK da Vertex AI para Python.

1. Liste os modelos que você pode implantar e registre o ID do modelo a ser implantado. Você pode listar os modelos Hugging Face com suporte no Model Garden e até mesmo filtrá-los por nome. A saída não inclui modelos ajustados.

   
   import vertexai
   from vertexai.preview 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', ...]
   

2. Confira as especificações de implantação de um modelo usando o ID da etapa anterior. É possível conferir o tipo de máquina, o tipo de acelerador e o URI da imagem do contêiner que o Model Garden verificou para um modelo específico.

   
   import vertexai
   from vertexai.preview 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 {
   #     ...
   #   }
   #   ...
   # ]
   

3. Implante um modelo em um endpoint. O Model Garden usa a configuração de implantação padrão, a menos que você especifique outros argumentos e valores.

   
   import vertexai
   from vertexai.preview 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?"}])
   

gcloud

Antes de começar, especifique um projeto de cota para executar os comandos a seguir. Os comandos executados são contabilizados de acordo com as cotas desse projeto. Para mais informações, consulte Definir o projeto de cota.

1. Liste os modelos que podem ser implantados executando o comando gcloud beta ai model-garden models list. Esse comando lista todos os IDs de modelo e quais deles você pode implantar.

   gcloud beta ai model-garden models list
   

   Na saída, encontre o ID do modelo a ser implantado. O exemplo a seguir mostra uma saída abreviada.

   MODEL_ID                                                                SUPPORTS_DEPLOYMENT
   google/gemma2@gemma-2-27b                                               Yes
   google/gemma2@gemma-2-27b-it                                            Yes
   google/gemma2@gemma-2-2b                                                Yes
   google/gemma2@gemma-2-2b-it                                             Yes
   google/gemma2@gemma-2-9b                                                Yes
   google/gemma2@gemma-2-9b-it                                             Yes
   google/[email protected]                                            Yes
   google/[email protected]                                      Yes
   google/[email protected]                                            Yes
   google/[email protected]                                      Yes
   google/gemma@gemma-2b                                                   Yes
   google/gemma@gemma-2b-gg-hf                                             Yes
   google/gemma@gemma-2b-it                                                Yes
   google/gemma@gemma-2b-it-gg-hf                                          Yes
   google/gemma@gemma-7b                                                   Yes
   google/gemma@gemma-7b-gg-hf                                             Yes
   google/gemma@gemma-7b-it                                                Yes
   google/gemma@gemma-7b-it-gg-hf                                          Yes
   

   A saída não inclui modelos ajustados ou modelos do Hugging Face. Para conferir quais modelos do Hugging Face são compatíveis, adicione a flag --list-supported-hugging-face-models.

2. Para conferir as especificações de implantação de um modelo, execute o comando gcloud beta ai model-garden models list-deployment-config. É possível conferir o tipo de máquina, o tipo de acelerador e o URI da imagem do contêiner com suporte do Model Garden para um modelo específico.

   gcloud beta ai model-garden models list-deployment-config \
       --model=MODEL_ID
   

   Substitua MODEL_ID pelo ID do modelo do comando de lista anterior, como google/gemma@gemma-2b ou stabilityai/stable-diffusion-xl-base-1.0.

3. Implante um modelo em um endpoint executando o comando gcloud beta ai model-garden models deploy. O Model Garden gera um nome de exibição para o endpoint e usa a configuração de implantação padrão, a menos que você especifique outros argumentos e valores.

   Para executar o comando de forma assíncrona, inclua a flag --asynchronous.

   gcloud beta 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]
   

   Substitua os seguintes marcadores de posição:

   • MODEL_ID: o ID do modelo do comando de lista anterior. Para modelos do Hugging Face, use o formato de URL do modelo do Hugging Face, como stabilityai/stable-diffusion-xl-base-1.0.
   • MACHINE_TYPE: define o conjunto de recursos a serem implantado para o modelo, como g2-standard-4.
   • ACCELERATOR_TYPE: especifica os aceleradores a serem adicionados à implantação para melhorar o desempenho ao trabalhar com cargas de trabalho intensas, como NVIDIA_L4.
   • ENDPOINT_NAME: um nome para o endpoint da Vertex AI implantado.
   • HF_ACCESS_TOKEN: para modelos do Hugging Face, se o modelo estiver bloqueado, forneça um token de acesso.
   • RESERVATION_RESOURCE_NAME: para usar uma reserva do Compute Engine específica, especifique o nome da sua reserva. Se você especificar uma reserva específica, não será possível especificar any-reservation.

   A saída inclui a configuração de implantação usada pelo Model Garden, o ID do endpoint e o ID da operação de implantação, que podem ser usados para verificar o status da implantação.

   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 [Vertex AI] -> [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
   

4. Para conferir detalhes sobre a implantação, execute o comando gcloud beta ai endpoints list --list-model-garden-endpoints-only:

   gcloud beta ai endpoints list --list-model-garden-endpoints-only \
       --region=LOCATION_ID
   

   Substitua LOCATION_ID pela região em que você implantou o modelo.

   A saída inclui todos os endpoints criados no Model Garden e informações como o ID, o nome e se o endpoint está associado a um modelo implantado. Para encontrar a implantação, procure o nome do endpoint retornado pelo comando anterior.

REST

Liste todos os modelos implantáveis e, em seguida, obtenha o ID do modelo a ser implantado. Em seguida, é possível implantar o modelo com a configuração e o endpoint padrão. Também é possível personalizar a implantação, como definir um tipo de máquina específico ou usar um endpoint dedicado.

1. Listar modelos que podem ser implantados

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• PROJECT_ID: o ID do projeto.
• QUERY_PARAMETERS: para listar os modelos do Model Garden, adicione os seguintes parâmetros de consulta: listAllVersions=True&filter=is_deployable(true). Para listar os modelos do Hugging Face, defina o filtro como alt=json&is_hf_wildcard(true)+AND+labels.VERIFIED_DEPLOYMENT_CONFIG%3DVERIFIED_DEPLOYMENT_SUCCEED&listAllVersions=True.

Método HTTP e URL:

GET https://aiplatform.googleapis.com/v1beta1/publishers/*/models?QUERY_PARAMETERS

Para enviar a solicitação, escolha uma destas opções:

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

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

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

Você vai receber uma resposta JSON semelhante a esta.

{
  "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. Implantar um modelo

Implante um modelo do Model Garden ou do Hugging Face. Também é possível personalizar a implantação especificando outros campos JSON.

Implante um modelo com a configuração padrão.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• LOCATION: uma região em que o modelo é implantado.
• PROJECT_ID: o ID do projeto.
• MODEL_ID: o ID do modelo a ser implantado, que pode ser encontrado na lista de todos os modelos implantáveis. O ID usa o seguinte formato: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION.

Método HTTP e URL:

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

Corpo JSON da solicitação:

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

Para enviar a solicitação, escolha uma destas opções:

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

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/v1beta1/projects/PROJECT_ID/locations/LOCATION:deploy"

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

$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/v1beta1/projects/PROJECT_ID/locations/LOCATION:deploy" | Select-Object -Expand Content

Você recebe uma resposta JSON semelhante a esta.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1beta1.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"
  }
}

Implantar um modelo do Hugging Face

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• LOCATION: uma região em que o modelo é implantado.
• PROJECT_ID: o ID do projeto.
• MODEL_ID: o ID do modelo do Hugging Face a ser implantado, que pode ser encontrado na lista de todos os modelos implantáveis. O ID usa o seguinte formato: PUBLISHER_NAME/MODEL_NAME.
• ACCESS_TOKEN: se o modelo estiver bloqueado, forneça um token de acesso.

Método HTTP e URL:

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

Corpo JSON da solicitação:

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

Para enviar a solicitação, escolha uma destas opções:

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

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/v1beta1/projects/PROJECT_ID/locations/LOCATION:deploy"

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

$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/v1beta1/projects/PROJECT_ID/locations/LOCATION:deploy" | Select-Object -Expand Content

Você recebe uma resposta JSON semelhante a esta.

{
  "name": "projects/PROJECT_ID/locations/us-central1LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1beta1.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"
  }
}

Implantar um modelo com personalizações

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

• LOCATION: uma região em que o modelo é implantado.
• PROJECT_ID: o ID do projeto.
• MODEL_ID: o ID do modelo a ser implantado, que pode ser encontrado na lista de todos os modelos implantáveis. O ID usa o seguinte formato: publishers/PUBLISHER_NAME/models/ MODEL_NAME@MODEL_VERSION, como google/gemma@gemma-2b ou stabilityai/stable-diffusion-xl-base-1.0.
• MACHINE_TYPE: define o conjunto de recursos a serem implantado para o modelo, como g2-standard-4.
• ACCELERATOR_TYPE: Especifica os aceleradores a serem adicionados à implantação para melhorar o desempenho ao trabalhar com cargas de trabalho intensas, como NVIDIA_L4
• ACCELERATOR_COUNT: o número de aceleradores a serem usados na implantação.
• reservation_affinity_type: para usar uma reserva do Compute Engine existente na sua implantação, especifique uma reserva específica ou qualquer reserva. Se você especificar esse valor, não especifique spot.
• spot: se é necessário usar VMs do Spot para a implantação.
• IMAGE_URI: o local da imagem do contêiner a ser usada, como us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241016_0916_RC00_maas.
• CONTAINER_ARGS: argumentos transmitidos ao contêiner durante a implantação.
• CONTAINER_PORT: um número de porta para o contêiner.
• fast_tryout_enabled: ao testar um modelo, você pode usar uma implantação mais rápida. Essa opção está disponível apenas para os modelos mais usados com determinados tipos de máquina. Se ativada, não é possível especificar configurações de modelo ou de implantação.

Método HTTP e URL:

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

Corpo JSON da solicitação:

{
  "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
  },
}

Para enviar a solicitação, escolha uma destas opções:

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

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/v1beta1/projects/PROJECT_ID/locations/LOCATION:deploy"

@'
{
  "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

$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/v1beta1/projects/PROJECT_ID/locations/LOCATION:deploy" | Select-Object -Expand Content

Você vai receber uma resposta JSON semelhante a esta.

{
  "name": "projects/PROJECT_ID/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1beta1.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"
  }
}

Console

1. No console Google Cloud , acesse a página Model Garden.

   Acessar o Model Garden

2. Encontre um modelo com suporte que você quer implantar e clique no card dele.

3. Clique em Implantar para abrir o painel Implantar modelo.

4. No painel Implantar modelo, especifique os detalhes da implantação.

   1. Use ou modifique os nomes do modelo e do endpoint gerados.
   2. Selecione um local para criar o endpoint do modelo.
   3. Selecione um tipo de máquina para cada nó da implantação.

   4. Para usar uma reserva do Compute Engine, na seção Deployment settings, selecione Advanced.

      Selecione um tipo de reserva no campo Tipo de reserva. A reserva precisa corresponder às especificações da máquina selecionada.

      • Usar automaticamente a reserva criada: a Vertex AI seleciona automaticamente uma reserva permitida com propriedades correspondentes. Se não houver capacidade na reserva selecionada automaticamente, a Vertex AI vai usar o pool de recursos Google Cloudgeral.
      • Selecionar reservas específicas: a Vertex AI usa uma reserva específica. Se não houver capacidade para a reserva selecionada, um erro será gerado.
      • Não usar (padrão): a Vertex AI usa o conjunto de recursosGoogle Cloud geral. Esse valor tem o mesmo efeito que não especificar uma reserva.

5. Clique em Implantar.

SDK da Vertex AI para Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Saiba mais na documentação de referência da API SDK da Vertex AI para Python.

No código, substitua os seguintes marcadores:

• LOCATION: a região em que você planeja implantar o modelo e o endpoint.
• PROJECT_ID: o ID do projeto.
• DISPLAY_NAME: um nome descritivo para o recurso associado.
• PUBLISHER_NAME: o nome do parceiro que fornece o modelo para upload ou implantação.
• PUBLISHER_MODEL_NAME: o nome do modelo a ser enviado.
• MACHINE_TYPE: define o conjunto de recursos a serem implantado para o modelo, como g2-standard-4. Você precisa corresponder a uma das configurações fornecidas pelo parceiro.
• ACCELERATOR_TYPE: especifica os aceleradores a serem adicionados à implantação para ajudar a melhorar o desempenho ao trabalhar com cargas de trabalho intensas, como NVIDIA_L4. Você precisa corresponder a uma das configurações fornecidas pelo parceiro.
• ACCELERATOR_COUNT: o número de aceleradores a serem usados. É necessário corresponder a uma das configurações fornecidas pelo parceiro.
• REQUEST_PAYLOAD: os campos e valores a serem incluídos na solicitação de previsão. Confira o card de modelo do Model Garden do parceiro para ver os campos disponíveis.

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

Liste todos os modelos implantáveis e, em seguida, obtenha o ID do modelo a ser implantado. Em seguida, é possível implantar o modelo com a configuração e o endpoint padrão. Também é possível personalizar a implantação, como definir um tipo de máquina específico ou usar um endpoint dedicado.

Nos comandos de curl de exemplo, substitua os seguintes marcadores:

• LOCATION: a região em que você planeja implantar o modelo e o endpoint.
• PROJECT_ID: o ID do projeto.
• DISPLAY_NAME: um nome descritivo para o recurso associado.
• PUBLISHER_NAME: o nome do parceiro que fornece o modelo para upload ou implantação.
• PUBLISHER_MODEL_NAME: o nome do modelo a ser enviado.
• ENDPOINT_ID: o ID do endpoint.
• MACHINE_TYPE: define o conjunto de recursos a serem implantado para o modelo, como g2-standard-4. Você precisa corresponder a uma das configurações fornecidas pelo parceiro.
• ACCELERATOR_TYPE: especifica os aceleradores a serem adicionados à implantação para ajudar a melhorar o desempenho ao trabalhar com cargas de trabalho intensas, como NVIDIA_L4. Você precisa corresponder a uma das configurações fornecidas pelo parceiro.
• ACCELERATOR_COUNT: o número de aceleradores a serem usados. É necessário corresponder a uma das configurações fornecidas pelo parceiro.
• REQUEST_PAYLOAD: os campos e valores a serem incluídos na solicitação de previsão. Confira o card de modelo do Model Garden do parceiro para ver os campos disponíveis.

1. Faça upload de um modelo para adicioná-lo ao Model Registry.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   https://LOCATION-aiplatform.googleapi.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",
         }
       }
     }
   }'
   

2. Crie um endpoint

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

3. Implante o modelo enviado no endpoint.

   curl -X POST \
   -H "Authorization: Bearer $(gcloud auth print-access-token)" \
   -H "Content-Type: application/json" \
   https://LOCATION-aiplatform.googleapi.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
     }
   }'
   

4. Depois que o modelo for implantado, você poderá fazer uma chamada unária ou de streaming para previsões. Confira o card de modelo do Model Garden do parceiro para saber quais métodos de API são aceitos.

   • Exemplo de chamada unária:

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

   • Exemplo de chamada de streaming:

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

Console

1. No console Google Cloud , acesse a página Model Garden.

   Acessar o Model Garden

2. Para encontrar um modelo específico, digite o nome dele na caixa de pesquisa do Model Garden.

3. Para conferir todos os modelos que podem ser implantados por conta própria, selecione Modelos de parceiros para autoimplantação na seção Coleções de modelos do painel de filtros. A lista resultante inclui todos os modelos de parceiros autoimplantáveis.

4. Clique no nome do modelo a ser implantado para abrir o card dele.

5. Clique em Opções de implantação.

6. No painel Deploy on Vertex AI, configure a implantação, como o local e o tipo de máquina.

7. Clique em Implantar.

Depois que a implantação for concluída, você poderá solicitar previsões usando o SDK ou a API. Há outras instruções disponíveis na seção "Documentação" do card do modelo.

SDK da Vertex AI para Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Saiba mais na documentação de referência da API SDK da Vertex AI para Python.

No código, substitua:

• PROJECT_ID pelo ID do projeto;
• LOCATION com sua região, por exemplo, "us-central1"
• ENDPOINT_ID pelo ID do 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

Nesses comandos, substitua:

• PROJECT_ID pelo nome do projeto;
• LOCATION_ID pela região em que você implantou o modelo e o endpoint
• ENDPOINT_ID com o ID do endpoint
• MODEL_ID com o ID do modelo do comando "list model"
• DEPLOYED_MODEL_ID pelo ID do modelo implantado

1. Encontre o ID do endpoint associado à sua implantação executando o comando gcloud ai endpoints list.

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

2. Encontre o ID do modelo executando o comando gcloud ai models list.

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

3. Use o ID do modelo do comando anterior para conferir o ID do modelo implantado executando o comando gcloud ai models describe.

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

   O resultado abreviado tem a aparência do exemplo a seguir. Na saída, o ID é chamado de 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
   ...
   

4. Execute o comando gcloud ai endpoints undeploy-model para desimplantar o modelo do endpoint usando o ID do endpoint e o ID do modelo implantado dos comandos anteriores.

   gcloud ai endpoints undeploy-model ENDPOINT_ID \
       --project=PROJECT_ID \
       --region=LOCATION_ID \
       --deployed-model-id=DEPLOYED_MODEL_ID
   

   Esse comando não produz saída.

Console

1. No console do Google Cloud , acesse a guia Endpoints na página Previsão on-line.

   Acessar o Endpoints

2. Na lista suspensa Região, escolha a região em que o endpoint está localizado.

3. Clique no nome do endpoint para abrir a página de detalhes.

4. Na linha do modelo, clique em more_vert Ações e selecione Desimplantar o modelo do endpoint.

5. Na caixa de diálogo Cancelar a implantação do modelo do endpoint, clique em Cancelar a implantação.

SDK da Vertex AI para Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Saiba mais na documentação de referência da API SDK da Vertex AI para Python.

No código, substitua:

• PROJECT_ID pelo ID do projeto;
• LOCATION com sua região, por exemplo, "us-central1"
• ENDPOINT_ID pelo ID do 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

• PROJECT_ID pelo nome do projeto;
• LOCATION_ID pela região em que você implantou o modelo e o endpoint
• ENDPOINT_ID com o ID do endpoint

1. Para excluir um endpoint, execute o comando gcloud ai endpoints list e confira o ID dele. Esse comando lista os IDs de todos os endpoints no seu projeto.

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

2. Execute o comando gcloud ai endpoints delete para excluir o endpoint.

   gcloud ai endpoints delete ENDPOINT_ID \
       --project=PROJECT_ID \
       --region=LOCATION_ID
   

   Quando solicitado, digite y para confirmar. Esse comando não produz saída.

Console

1. No console do Google Cloud , acesse a guia Endpoints na página Previsão on-line.

   Acessar o Endpoints

2. Na lista suspensa Região, escolha a região em que o endpoint está localizado.

3. No final da linha do endpoint, clique em more_vert Ações e selecione Excluir endpoint.

4. No prompt de confirmação, clique em Confirmar.

SDK da Vertex AI para Python

Para saber como instalar o SDK da Vertex AI para Python, consulte Instalar o SDK da Vertex AI para Python. Saiba mais na documentação de referência da API SDK da Vertex AI para Python.

No código, substitua:

• PROJECT_ID pelo ID do projeto;
• LOCATION com sua região, por exemplo, "us-central1"
• MODEL_ID pelo ID do modelo

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

• PROJECT_ID pelo nome do projeto;
• LOCATION_ID pela região em que você implantou o modelo e o endpoint
• MODEL_ID com o ID do modelo do comando "list model"

1. Encontre o ID do modelo a ser excluído executando o comando gcloud ai models list.

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

2. Execute o comando gcloud ai models delete para excluir o modelo fornecendo o ID e o local do modelo.

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

Console

1. Acesse a página Registro do modelo na seção "Vertex AI" do console Google Cloud .

   Acessar a página "Modelo de registro"

2. Na lista suspensa Região, escolha a região em que você implantou o modelo.

3. Na linha do modelo, clique em more_vert Ações e selecione Excluir modelo.

   Quando você exclui o modelo, todas as versões e avaliações de modelo associadas são excluídas do projeto Google Cloud .

4. No aviso de confirmação, clique em Excluir.