Implantar modelos com pesos personalizados

A implantação de modelos com pesos personalizados é uma oferta em pré-lançamento. É possível ajustar modelos com base em um conjunto predefinido de modelos de base e implantar os modelos personalizados no Model Garden da Gemini Enterprise Agent Platform. É possível implantar seus modelos personalizados usando a importação de pesos personalizados. Para isso, faça upload dos artefatos do modelo para um bucket do Cloud Storage no seu projeto, o que é uma experiência de um clique na Agent Platform.

O suporte do VPC Service Controls para pesos personalizados está disponível.

Modelos compatíveis

O acesso antecipado de Implantar modelos com pesos personalizados é compatível com os seguintes modelos de base:

Limitações

Os pesos personalizados não são compatíveis com a importação de modelos quantizados.

Arquivos de modelo

É necessário fornecer os arquivos do modelo no formato de pesos do Hugging Face. Para mais informações sobre o formato de pesos do Hugging Face, consulte Usar modelos do Hugging Face.

Se os arquivos necessários não forem fornecidos, a implantação do modelo poderá falhar.

Esta tabela lista os tipos de arquivos de modelo, que dependem da arquitetura do modelo:

Locais

É possível implantar modelos personalizados em todas as regiões dos serviços do Model Garden.

Pré-requisitos

Nesta seção, mostramos como implantar seu modelo personalizado.

Antes de começar

1. In the Cloud de Confiance console, on the project selector page, select or create a Cloud de Confiance project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

   Go to project selector

2. Verify that billing is enabled for your Cloud de Confiance project.

3. Enable the Agent Platform API, if it is not already enabled.

   Roles required to enable APIs

   To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

   Enable the API

4. No console do Cloud de Confiance , ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte inferior do console do Cloud de Confiance , uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

Neste tutorial, presumimos que você esteja usando o Cloud Shell para interagir com o Cloud de Confiance by S3NS. Se você quiser usar um shell diferente em vez do Cloud Shell, execute a seguinte configuração extra:

1. Instale a CLI do Google Cloud.

2. Configure a CLI gcloud para usar sua identidade federada.

   Para mais informações, consulte Fazer login na CLI gcloud com sua identidade federada.

3. Para inicializar a CLI gcloud, execute o seguinte comando:

   gcloud init

Implantar o modelo personalizado

Nesta seção, mostramos como implantar seu modelo personalizado.

Se você estiver usando a interface de linha de comando (CLI), Python ou JavaScript, substitua as seguintes variáveis por um valor para que os exemplos de código funcionem:

• REGION: sua região. Por exemplo, uscentral1.
• MODEL_GCS: seu modelo do Cloud de Confiance by S3NS . Por exemplo, gs://custom-weights-fishfooding/meta-llama/Llama-3.2-1B-Instruct.
• PROJECT_ID: o ID do projeto.
• MODEL_ID: o ID do modelo.
• MACHINE_TYPE: o tipo de máquina. Por exemplo, g2-standard-12.
• ACCELERATOR_TYPE: o tipo de acelerador. Por exemplo, NVIDIA_L4.
• ACCELERATOR_COUNT: sua contagem de aceleradores.

• PROMPT: seu comando de texto.

gcloud ai model-garden models deploy --model=${MODEL_GCS} --region ${REGION}

gcloud ai model-garden models deploy --model=${MODEL_GCS} --machine-type=${MACHINE_TYE} --accelerator-type=${ACCELERATOR_TYPE} --accelerator-count=${ACCELERATOR_COUNT} --region ${REGION}

import vertexai
from google.cloud import aiplatform
from vertexai.preview import model_garden

vertexai.init(project=${PROJECT_ID}, location=${REGION})
custom_model = model_garden.CustomModel(
  gcs_uri=GCS_URI,
)
endpoint = custom_model.deploy(
  machine_type="${MACHINE_TYPE}",
  accelerator_type="${ACCELERATOR_TYPE}",
  accelerator_count="${ACCELERATOR_COUNT}",
  model_display_name="custom-model",
  endpoint_display_name="custom-model-endpoint")

endpoint.predict(instances=[{"prompt": "${PROMPT}"}], use_dedicated_endpoint=True)

import vertexai
from google.cloud import aiplatform
from vertexai.preview import model_garden

vertexai.init(project=${PROJECT_ID}, location=${REGION})
custom_model = model_garden.CustomModel(
  gcs_uri=GCS_URI,
)
endpoint = custom_model.deploy()

endpoint.predict(instances=[{"prompt": "${PROMPT}"}], use_dedicated_endpoint=True)

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/${REGION}:deploy" \
  -d '{
    "custom_model": {
    "gcs_uri": "'"${MODEL_GCS}"'"
  },
  "destination": "projects/'"${PROJECT_ID}"'/locations/'"${REGION}"'",
  "model_config": {
     "model_user_id": "'"${MODEL_ID}"'",
  },
}'

curl -X POST \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://${REGION}-aiplatform.googleapis.com/v1beta1/projects/${PROJECT_ID}/locations/${REGION}:deploy" \
  -d '{
    "custom_model": {
    "gcs_uri": "'"${MODEL_GCS}"'"
  },
  "destination": "projects/'"${PROJECT_ID}"'/locations/'"${REGION}"'",
  "model_config": {
     "model_user_id": "'"${MODEL_ID}"'",
  },
  "deploy_config": {
    "dedicated_resources": {
      "machine_spec": {
        "machine_type": "'"${MACHINE_TYPE}"'",
        "accelerator_type": "'"${ACCELERATOR_TYPE}"'",
        "accelerator_count": '"${ACCELERATOR_COUNT}"'
      },
      "min_replica_count": 1
    }
  }
}'

Implantar usando a API

O VPC Service Controls só funciona com o endpoint dedicado particular. Portanto, é necessário definir o private_service_connect_config no exemplo de código a seguir, que demonstra como implantar usando a API:

  curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://us-central1-aiplatform.googleapis.com/v1beta1/projects/YOUR_PROJECT/locations/us-central1:deploy" \
    -d '{
      "custom_model": {
        "model_id": "test-mg-deploy-092301",
        "gcs_uri": "gs://YOUR_GCS_BUCKET"
      },
      "destination": "projects/YOUR_PROJECT/locations/us-central1",
      "endpoint_config": {
        "endpoint_display_name": "psc-ep1",
        "private_service_connect_config": {
          "enablePrivateServiceConnect": true,
          "projectAllowlist": ["YOUR_PROJECT"]
        }
      },
      "deploy_config": {
        "dedicated_resources": {
          "machine_spec": {
            "machine_type": "g2-standard-24",
            "accelerator_type": "NVIDIA_L4",
            "accelerator_count": 2
          },
          "min_replica_count": 1,
          "max_replica_count": 1
        }
      }
    }'

Receber o ID do endpoint e do modelo usando o console do Cloud de Confiance

Depois que a implantação for concluída, siga estas etapas:

1. No console do Cloud de Confiance , acesse a página Model Garden.

   Acessar o Model Garden

2. Clique em Mostrar meus endpoints e modelos.

3. Na tabela Meus endpoints, verifique o endpoint que você acabou de implantar na coluna Nome. A página Detalhes é exibida.

4. Clique no modelo na tabela Modelos implantados.

5. Selecione a página Detalhes da versão. O ID do modelo é exibido na linha Variáveis de ambiente da tabela.

Configurar o Private Service Connect

Você está adicionando um novo endpoint para acessar as APIs do S3NS . Esse endpoint pode ser usado em todas as regiões da rede VPC selecionada. Além disso, considere o seguinte:

• Os clientes em redes conectadas à rede VPC do endpoint usando conectividade híbrida podem acessar o endpoint. Para mais informações, consulte Acessar APIs doS3NS por endpoints.
• Clientes em redes VPC com peering não podem acessar o endpoint.

Endpoint de lista para receber o anexo de serviço

Este exemplo de código demonstra como listar um endpoint para receber um anexo de serviço.

$ curl \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  "https://us-central1-aiplatform.googleapis.com/v1beta1/projects/YOUR_PROJECT/locations/us-central1/endpoints/YOUR_ENDPOINT_ID"

  {
  "name": "projects/440968033208/locations/us-central1/endpoints/mg-endpoint-2c6ae2be-1491-43fe-b179-cb5a63e2c955",
  "displayName": "psc-ep1",
  "deployedModels": [
    {
      "id": "4026753529031950336",
      "model": "projects/440968033208/locations/us-central1/models/mg-custom-1758645924",
      "displayName": "null-null-null-1758645933",
      "createTime": "2025-09-23T16:45:45.169195Z",
      "dedicatedResources": {
        "machineSpec": {
          "machineType": "g2-standard-24",
          "acceleratorType": "NVIDIA_L4",
          "acceleratorCount": 2
        },
        "minReplicaCount": 1,
        "maxReplicaCount": 1
      },
      "enableContainerLogging": true,
      "privateEndpoints": {
        "serviceAttachment": "projects/qdb392d34e2a11149p-tp/regions/us-central1/serviceAttachments/gkedpm-fbbc4061323c91c14ab4d961a2f8b0"
      },
      "modelVersionId": "1",
      "status": {
        "lastUpdateTime": "2025-09-23T17:26:10.031652Z",
        "availableReplicaCount": 1
      }
    }
  ],
  "trafficSplit": {
    "4026753529031950336": 100
  },
  "etag": "AMEw9yPIWQYdbpHu6g6Mhpu1_10J062_oR9Jw9txrp8dFFbel7odLgSK8CGIogAUkR_r",
  "createTime": "2025-09-23T16:45:45.169195Z",
  "updateTime": "2025-09-23T17:13:36.320873Z",
  "privateServiceConnectConfig": {
    "enablePrivateServiceConnect": true,
    "projectAllowlist": [
      "ucaip-vpc-s-1605069239-dut-24"
    ]
  }
}

Criar um Private Service Connect

Para criar um Private Service Connect (PSC), siga estas etapas:

1. No console do Cloud de Confiance , acesse a página Private Service Connect. A página Endpoints conectados é exibida.

   Acessar a página "Private Service Connect"

2. Clique em + Conectar endpoint. A página Conectar endpoint é exibida.

3. Selecione uma opção no campo Destino. É possível escolher as APIs do Google que dão acesso à maioria das APIs e serviços do S3NS ou o Serviço publicado que dá acesso a um serviço publicado.

4. Na seção Detalhes do destino, selecione um valor na lista Escopo e um valor na lista Tipo de pacote.

5. Na seção Detalhes do endpoint, faça o seguinte:

   1. Insira um nome no campo Nome do endpoint.
   2. Selecione um valor na lista Rede. Selecione uma rede VPC localizada no seu projeto. Se você precisar criar um endpoint do PSC em um projeto de serviço que usa uma rede VPC compartilhada em um projeto host, use a Google Cloud CLI ou envie uma solicitação de API.
   3. Selecione um valor na lista Endereço IP.

6. Abra a seção Diretório de serviços.

7. Selecione uma região na lista Região.

8. Selecione um namespace na lista Namespace.

9. Clique em Adicionar endpoint. A tabela Endpoints é atualizada com uma linha para o novo endpoint.

Fazer uma consulta

Nesta seção, explicamos como criar um endpoint público e um particular.

Fazer uma consulta a um endpoint público

Depois que o modelo é implantado, os pesos personalizados dão suporte ao endpoint dedicado público. É possível enviar consultas usando a API ou o SDK.

Antes de enviar consultas, você precisa receber o URL do endpoint, o ID do endpoint e o ID do modelo, que estão disponíveis no console do Cloud de Confiance .

Siga estas etapas para acessar as informações:

1. No console do Cloud de Confiance , acesse a página Model Garden.

   Model Garden

2. Clique em Mostrar meus endpoints e modelos.

3. Selecione sua região na lista Região.

4. Para conferir o ID e o URL do endpoint, clique nele na seção Meus endpoints.

   O ID do endpoint é exibido no campo ID do endpoint.

   O URL do endpoint público é exibido no campo Endpoint dedicado.

5. Para encontrar o ID do modelo, localize o modelo listado na seção Modelos implantados e siga estas etapas:

   1. Clique no nome do modelo implantado no campo Modelo.
   2. Clique em Detalhes da versão. O ID do modelo é exibido no campo ID do modelo.

Depois de receber as informações do endpoint e do modelo implantado, consulte os exemplos de código a seguir para saber como enviar uma solicitação de inferência ou consulte Enviar uma solicitação de inferência on-line para um endpoint público dedicado.

  curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://${ENDPOINT_URL}/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${ENDPOINT_ID}/chat/completions" \
    -d '{
    "model": "'"${MODEL_ID}"'",
    "temperature": 0,
    "top_p": 1,
    "max_tokens": 154,
    "ignore_eos": true,
    "messages": [
      {
        "role": "user",
        "content": "How to tell the time by looking at the sky?"
      }
    ]
  }'

  curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \  "https://${ENDPOINT_URL}/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${ENDPOINT_ID}/chat/completions" \
    -d '{
    "model": "'"${MODEL_ID}"'",
    "stream": true,
    "temperature": 0,
    "top_p": 1,
    "max_tokens": 154,
    "ignore_eos": true,
    "messages": [
      {
        "role": "user",
        "content": "How to tell the time by looking at the sky?"
      }
    ]
  }'

  curl -X POST \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
  "https://${ENDPOINT_URL}/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${ENDPOINT_ID}:predict" \
    -d '{
    "instances": [
      {
        "prompt": "How to tell the time by looking at the sky?",
        "temperature": 0,
        "top_p": 1,
        "max_tokens": 154,
        "ignore_eos": true
      }
    ]
  }'

  curl -X POST \
    -N \
    --output - \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://${ENDPOINT_URL}/v1beta1/projects/${PROJECT_ID}/locations/${LOCATION}/endpoints/${ENDPOINT_ID}:streamRawPredict" \
    -d '{
    "instances": [
      {
        "prompt": "How to tell the time by looking at the sky?",
        "temperature": 0,
        "top_p": 1,
        "max_tokens": 154,
        "ignore_eos": true,
        "stream": true
      }
    ]
  }'

  from google.cloud import aiplatform

  project_id = ""
  location = ""
  endpoint_id = "" # Use the short ID here

  aiplatform.init(project=project_id, location=location)

  endpoint = aiplatform.Endpoint(endpoint_id)

  prompt = "How to tell the time by looking at the sky?"
  instances=[{"text": prompt}]
  response = endpoint.predict(instances=instances, use_dedicated_endpoint=True)
  print(response.predictions)

Fazer uma consulta para um endpoint particular

É possível testar a consulta usando um notebook ou uma VM no projeto permitido.

Neste exemplo de consulta, é possível substituir variáveis pelo IP, projeto, ID do endpoint e ID do modelo (recebido na etapa de implantação acima)

curl -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" 'https://YOUR_IP/v1beta1/projects/YOUR_PROJECT_ID/locations/YOUR_LOCATION/endpoints/YOUR_ENDPOINT_ID/chat/completions' -d '{ "model": "YOUR_MODEL_ID", "max_tokens": 300, "messages": [{ "role": "user", "content": "how to tell the time by looking at sky?" }]}'

$ curl -k -X POST -H "Authorization: Bearer $(gcloud auth print-access-token)" -H "Content-Type: application/json" 'https:/YOUR_IP/v1beta1/projects/YOUR_PROJECT_ID/locations/YOUR_LOCATION/endpoints/YOUR_ENDPOINT_ID:predict' -d '{
  "instances": [
    {
      "prompt": "Summarize Goog stock performance",
      "temperature": 0,
      "top_p": 1,
      "max_tokens": 154,
      "ignore_eos": true
    }
  ]
}'

Para ver outro exemplo de como usar a API, consulte o notebook Importar pesos personalizados.

Saiba mais sobre os modelos autoimplantados na Gemini Enterprise Agent Platform

• Para mais informações sobre os endpoints dedicados particulares de previsão on-line da plataforma de agentes do Gemini Enterprise, consulte Usar endpoints particulares dedicados com base no Private Service Connect para inferência on-line.
• Para mais informações sobre modelos com implantação própria, consulte Visão geral de modelos com implantação própria.
• Para mais informações sobre o Model Garden, consulte Visão geral do Model Garden.
• Para mais informações sobre como implantar modelos, consulte Usar modelos no Model Garden.
• Usar modelos abertos do Gemma
• Usar modelos abertos de Llama
• Usar modelos abertos do Hugging Face