Implemente modelos com ponderações personalizadas

A implementação de modelos com ponderações personalizadas é uma oferta de pré-visualização. Pode otimizar os modelos com base num conjunto predefinido de modelos base e implementar os seus modelos personalizados no Vertex AI Model Garden. Pode implementar os seus modelos personalizados usando a importação de pesos personalizados carregando os artefactos do modelo para um contentor do Cloud Storage no seu projeto, o que é uma experiência de um clique na Vertex AI.

O suporte dos VPC Service Controls para ponderações personalizadas está disponível.

Modelos suportados

A pré-visualização pública da funcionalidade Implementar modelos com ponderações personalizadas é suportada pelos seguintes modelos base:

Nome do modelo Versão
Llama
  • Llama-2: 7B e 13B
  • Llama-3.1: 8B e 70B
  • Llama-3.2: 1B e 3B
  • Llama-4: Scout-17B, Maverick-17B
  • CodeLlama-13B
Gemma
  • Gemma-2: 9B e 27B
  • Gemma-3: 1B, 4B, 3-12B, 27B
  • Medgemma: 4B, 27B-text
Qwen
  • Qwen2: 1,5 mil milhões
  • Qwen2.5: 0,5 mil milhões, 1,5 mil milhões, 7 mil milhões e 32 mil milhões
  • Qwen3: 0,6 B, 1,7 B, 8 B, 32 B, Qwen3-Coder-480B-A35B-Instruct, Qwen3-Next-80B-A3B-Instruct, Qwen3-Next-80B-A3B-Thinking
Deepseek
  • Deepseek-R1
  • Deepseek-V3
  • DeepSeek-V3.1
Mistral e Mixtral
  • Mistral-7B-v0.1
  • Mixtral-8x7B-v0.1
  • Mistral-Nemo-Base-2407
Phi-4
  • Phi-4-reasoning
OpenAI OSS
  • gpt-oss: 20B, 120B

Limitações

As ponderações personalizadas não suportam a importação de modelos quantizados.

Ficheiros do modelo

Tem de fornecer os ficheiros do modelo no formato de pesos do Hugging Face. Para mais informações sobre o formato de ponderações do Hugging Face, consulte o artigo Use modelos do Hugging Face.

Se os ficheiros necessários não forem fornecidos, a implementação do modelo pode falhar.

Esta tabela apresenta os tipos de ficheiros de modelos, que dependem da arquitetura do modelo:

Conteúdo do ficheiro de modelo Tipo de ficheiro
Configuração do modelo
  • config.json
Pesos do modelo
  • *.safetensors
  • *.bin
Índice de pesos
  • *.index.json
Ficheiros do tokenizador
  • tokenizer.model
  • tokenizer.json
  • tokenizer_config.json

Localizações

Pode implementar modelos personalizados em todas as regiões a partir dos serviços do Model Garden.

Pré-requisitos

Esta secção demonstra como implementar o seu modelo personalizado.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud 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

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud 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

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

    8.

  8. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

    9. Este tutorial pressupõe que está a usar a Cloud Shell para interagir com o Google Cloud. Se quiser usar uma shell diferente da Cloud Shell, faça a seguinte configuração adicional:

    1. Install the Google Cloud CLI.

    2. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

    3. To initialize the gcloud CLI, run the following command: 

      gcloud init

    Implemente o modelo personalizado

    Esta secção demonstra como implementar o seu modelo personalizado.

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

    • REGION: a sua região. Por exemplo, uscentral1.
    • MODEL_GCS: o seu modelo Google Cloud . Por exemplo, gs://custom-weights-fishfooding/meta-llama/Llama-3.2-1B-Instruct.
    • PROJECT_ID: o ID do projeto.
    • MODEL_ID: o ID do seu 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: a quantidade de aceleradores.

    • PROMPT: o seu comando de texto.

    Consola

    Os passos seguintes mostram como usar a Google Cloud consola para implementar o seu modelo com ponderações personalizadas.

    1. Na Google Cloud consola, aceda à página Model Garden.

      Aceda ao Model Garden

    2. Clique em Implementar modelo com ponderações personalizadas. É apresentado o painel Implemente um modelo com ponderações personalizadas.

    3. Na secção Origem do modelo, faça o seguinte:

      1. Clique em Procurar, escolha o contentor onde o modelo está armazenado e clique em Selecionar.

      2. Opcional: introduza o nome do modelo no campo Nome do modelo.

    4. Na secção Definições de implementação, faça o seguinte:

      1. No campo Região, selecione a sua região e clique em OK.

      2. No campo Especificação da máquina, selecione a especificação da máquina que é usada para implementar o seu modelo.

      3. Opcional: no campo Nome do ponto final, o ponto final do modelo é apresentado por predefinição. No entanto, pode introduzir um nome de ponto final diferente no campo.

      4. Se o seu projeto aplicar o VPC-SC ou se preferir o acesso privado, selecione Privado (Private Service Connect) no campo Acesso ao ponto final. Caso contrário, selecione Público.

      5. Se usar um Private Service Connect, introduza os IDs dos projetos no campo IDs dos projetos, que são os projetos onde os clientes de consultas são executados, ou clique em Selecionar IDs dos projetos para apresentar uma caixa de diálogo com IDs dos projetos.

        Se clicar em Selecionar IDs dos projetos, faça o seguinte:

        1. Encontre o seu projeto que contém o código que está a tentar aceder ao modelo.
        2. Clique na caixa de verificação do seu projeto.
        3. Clique em Selecionar.

    5. Clique em Implementar.

    CLI gcloud

    Este comando demonstra como implementar o modelo numa região específica.

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

    Este comando demonstra como implementar o modelo numa região específica com o respetivo tipo de máquina, tipo de acelerador e número de aceleradores. Se quiser selecionar uma configuração de máquina específica, tem de definir todos os três campos.

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

    Python 

    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)

    Em alternativa, não tem de transmitir um parâmetro ao método custom_model.deploy().

    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 

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

    Em alternativa, pode usar a API para definir explicitamente o tipo de máquina.

    
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
    }
  }
}'

    Faça a implementação através da API

    Os VPC Service Controls só funcionam com o ponto final dedicado privado. Por conseguinte, tem de definir o private_service_connect_config no seguinte exemplo de código, que demonstra como implementar através da API:

    curl 

      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
        }
      }
    }'

    Obtenha o ID do ponto final e o ID do modelo através da Google Cloud consola

    Após a conclusão da implementação, siga estes passos:

    1. Na Google Cloud consola, aceda à página Model Garden.

      Aceda ao Model Garden

    2. Clique em Ver os meus pontos finais e modelos.

    3. Na tabela Os meus pontos finais, verifique o ponto final que acabou de implementar na coluna Nome. É apresentada a página Detalhes.

    4. Clique no modelo na tabela Modelos implementados.

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

    Configure um Private Service Connect

    Está a adicionar um novo ponto final para aceder às Google APIs. Este ponto final pode ser usado em todas as regiões da rede de VPC que selecionar. Além disso, considere o seguinte:

    • Os clientes em redes ligadas à rede VPC do ponto final através de conetividade híbrida podem aceder ao ponto final. Para mais informações, consulte o artigo Aceda às Google APIs através de pontos finais.
    • Os clientes em redes VPCs com intercâmbio não podem aceder ao ponto final.

    Ponto final da lista para obter a associação de serviços

    Este exemplo de código demonstra como listar um ponto final para obter uma associação de serviço.

    curl 

    $ 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"

    Esta é a resposta do ponto final da lista.

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

    Crie um Private Service Connect

    Para criar uma ligação do Private Service Connect (PSC), siga estes passos:

    1. Na Google Cloud consola, aceda à página Private Service Connect. É apresentada a página Pontos finais ligados.

      Aceda ao Private Service Connect

    2. Clique em + Associar ponto final. É apresentada a página Ponto final de ligação.

    3. Selecione uma opção no campo Destino. Pode escolher APIs Google que fornecem acesso à maioria das Google APIs e serviços ou Serviço publicado que fornece acesso a um serviço publicado.

    4. Na secção Detalhes do alvo, selecione um valor na lista Âmbito e selecione um valor na lista Tipo de pacote.

    5. Na secção Detalhes do ponto final, faça o seguinte:

      1. Introduza um nome no campo Nome do ponto final.
      2. Selecione um valor na lista Rede. Selecione uma rede de VPC localizada no seu projeto. Se tiver de criar um ponto final do PSC num projeto de serviço que use uma rede de VPC partilhada num projeto anfitrião, use a Google Cloud CLI ou envie um pedido de API.
      3. Selecione um valor na lista Endereço IP.

    6. Expanda a secção Diretório de serviços.

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

    8. Selecione um espaço de nomes na lista Espaço de nomes.

    9. Clique em Adicionar ponto final. A tabela Pontos finais é atualizada com uma linha para o seu novo ponto final.

    Faça uma consulta

    Esta secção explica como criar um ponto final público e um ponto final privado.

    Faça uma consulta a um ponto final público

    Após a implementação do modelo, os pesos personalizados suportam o ponto final dedicado público. Pode enviar consultas através da API ou do SDK.

    Antes de enviar consultas, tem de obter o URL do ponto final, o ID do ponto final e o ID do modelo, que estão disponíveis na Google Cloud consola.

    Siga estes passos para obter as informações:

    1. Na Google Cloud consola, aceda à página Model Garden.

      Model Garden

    2. Clique em Ver os meus pontos finais e modelos.

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

    4. Para obter o ID do ponto final e o URL do ponto final, clique no ponto final na secção Os meus pontos finais.

      O ID do ponto final é apresentado no campo ID do ponto final.

      O URL do seu ponto final público é apresentado no campo Ponto final dedicado.

    5. Para obter o ID do modelo, encontre o seu modelo na secção Modelos implementados e siga estes passos:

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

    Depois de obter as informações do ponto final e do modelo implementado, consulte os seguintes exemplos de código para saber como enviar um pedido de inferência ou consulte o artigo Envie um pedido de inferência online para um ponto final público dedicado.

    API

    Os exemplos de código seguintes demonstram diferentes formas de usar a API com base no seu exemplo de utilização.

    Conclusão de chat (unária)

    Este pedido de amostra envia uma mensagem de chat completa para o modelo e recebe uma resposta num único bloco após a geração da resposta completa. Isto é semelhante a enviar uma mensagem de texto e receber uma única resposta completa.

      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?"
      }
    ]
  }'

    Conclusão do chat (streaming)

    Este pedido é a versão de streaming do pedido de conclusão de chat unário. Ao adicionar "stream": true ao pedido, o modelo envia a respetiva resposta parte por parte à medida que é gerada. Isto é útil para criar um efeito em tempo real semelhante a uma máquina de escrever numa aplicação de chat.

      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?"
      }
    ]
  }'

    Prever

    Este pedido envia um comando direto para obter uma inferência de um modelo. Isto é usado frequentemente para tarefas que não são necessariamente conversacionais, como a classificação ou o resumo de texto.

      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
      }
    ]
  }'

    Previsão não processada

    Este pedido é uma versão de streaming do pedido Predict. Ao usar o ponto final :streamRawPredict e incluir "stream": true, este pedido envia um comando direto e recebe a saída do modelo como um fluxo contínuo de dados à medida que são gerados, o que é semelhante ao pedido de conclusão de chat com streaming.

      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
      }
    ]
  }'

    SDK

    Este exemplo de código usa o SDK para enviar uma consulta a um modelo e receber uma resposta desse modelo.

      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)

    Faça uma consulta para um ponto final privado

    Pode testar a sua consulta usando um bloco de notas ou uma VM no projeto permitido.

    Esta consulta de exemplo permite-lhe substituir as variáveis pelo seu IP, projeto, ID do ponto final e ID do modelo (obtido no passo de implementação acima)

    curl

    Conclusão de chat

    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?" }]}'

    Prever

    $ 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 bloco de notas Import Custom Weights.

    Saiba mais sobre os modelos implementados autonomamente na Vertex AI