Implementa modelos con pesos personalizados

La implementación de modelos con pesos personalizados es una oferta en versión preliminar. Puedes ajustar modelos en función de un conjunto predefinido de modelos básicos y, luego, implementar tus modelos personalizados en Model Garden de Gemini Enterprise Agent Platform. Puedes implementar tus modelos personalizados con la importación de pesos personalizados. Para ello, sube los artefactos de tu modelo a un bucket de Cloud Storage en tu proyecto, lo que se realiza con un solo clic en Agent Platform.

Ya está disponible la compatibilidad con los Controles del servicio de VPC para pesos personalizados.

Modelos compatibles

La versión preliminar pública de Deploy models with custom weights es compatible con los siguientes modelos básicos:

Nombre del modelo Versión
Llama
  • Llama-2: 7B y 13B
  • Llama-3.1: 8B y 70B
  • Llama-3.2: 1B y 3B
  • Llama 4: Scout-17B, Maverick-17B
  • CodeLlama-13B
Gemma
  • Gemma-2: 9B y 27B
  • Gemma-3: 1B, 4B, 3-12B y 27B
  • Gemma-4: 26B-A4B-it, 31B-it, E2B-it, E4B-it
  • MedGemma: 4B, 27B-text
Qwen
  • Qwen2: 1,500 millones
  • Qwen2.5: 0.5B, 1.5B, 7B, 32B
  • Qwen3: 0.6B, 1.7B, 4B, 8B, 32B, Qwen3-Coder-480B-A35B-Instruct, Qwen3-Next-80B-A3B-Instruct, Qwen3-Next-80B-A3B-Thinking, Qwen3-VL-8B-Instruct
  • Qwen3.5: 9B
Deepseek
  • Deepseek-R1
  • Deepseek-V3
  • DeepSeek-V3.1
Mistral y Mixtral
  • Mistral-7B-v0.1
  • Mixtral-8x7B-v0.1
  • Mistral-Nemo-Base-2407
Phi-4
  • Phi-4-reasoning
OSS de OpenAI
  • gpt-oss: 20B, 120B

Limitaciones

Los pesos personalizados no admiten la importación de modelos cuantificados.

Archivos de modelos

Debes proporcionar los archivos del modelo en el formato de pesos de Hugging Face. Para obtener más información sobre el formato de pesos de Hugging Face, consulta Usa modelos de Hugging Face.

Si no se proporcionan los archivos requeridos, es posible que falle la implementación del modelo.

En esta tabla, se enumeran los tipos de archivos de modelos, que dependen de la arquitectura del modelo:

Contenido del archivo del modelo Tipo de archivo
Configuración del modelo
  • config.json
Pesos del modelo
  • *.safetensors
  • *.bin
Índice de peso
  • *.index.json
Archivos del tokenizador
  • tokenizer.model
  • tokenizer.json
  • tokenizer_config.json

Ubicaciones

Puedes implementar modelos personalizados en todas las regiones desde los servicios de Model Garden.

Requisitos previos

En esta sección, se muestra cómo implementar tu modelo personalizado.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

  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 Agent Platform 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 Agent Platform 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. En la consola de Google Cloud , activa Cloud Shell.

    Activa Cloud Shell

    En la parte inferior de la consola de Google Cloud , se inicia una sesión de Cloud Shell que muestra una ventana emergente con una línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

En este instructivo, se supone que usas Cloud Shell para interactuar con Google Cloud. Si quieres usar un shell diferente en lugar de Cloud Shell, realiza la siguiente configuración adicional:

  1. Instala Google Cloud CLI.

  2. Si usas un proveedor de identidad externo (IdP), primero debes acceder a la gcloud CLI con tu identidad federada.

  3. Para inicializar gcloud CLI, ejecuta el siguiente comando: 

    gcloud init

Implementa el modelo personalizado

En esta sección, se muestra cómo implementar tu modelo personalizado.

Si usas la interfaz de línea de comandos (CLI), Python o JavaScript, reemplaza las siguientes variables por un valor para que funcionen tus muestras de código:

  • REGION: Tu región. Por ejemplo, uscentral1.
  • MODEL_GCS: Tu modelo Google Cloud . Por ejemplo, gs://custom-weights-fishfooding/meta-llama/Llama-3.2-1B-Instruct.
  • PROJECT_ID: ID del proyecto.
  • MODEL_ID: Es el ID de tu modelo.
  • MACHINE_TYPE: Es el tipo de máquina. Por ejemplo, g2-standard-12.
  • ACCELERATOR_TYPE: Es el tipo de acelerador. Por ejemplo, NVIDIA_L4.
  • ACCELERATOR_COUNT: Es la cantidad de aceleradores.

  • PROMPT: Es tu instrucción de texto.

Console

En los siguientes pasos, se muestra cómo usar la consola de Google Cloud para implementar tu modelo con pesos personalizados.

  1. En la consola de Google Cloud , ve a la página Model Garden.

    Ir a Model Garden

  2. Haz clic en Implementar modelo con pesos personalizados. Aparecerá el panel Implementa un modelo con pesos personalizados.

  3. En la sección Fuente del modelo, haz lo siguiente:

    1. Haz clic en Explorar, elige el bucket en el que se almacena tu modelo y haz clic en Seleccionar.

    2. Opcional: Ingresa el nombre del modelo en el campo Nombre del modelo.

  4. En la sección Configuración de la implementación, haz lo siguiente:

    1. En el campo Región, selecciona tu región y haz clic en Aceptar.

    2. En el campo Especificación de la máquina, selecciona la especificación de la máquina que se usará para implementar tu modelo.

    3. Opcional: En el campo Nombre del extremo, aparece el extremo de tu modelo de forma predeterminada. Sin embargo, puedes ingresar un nombre de extremo diferente en el campo.

    4. Si tu proyecto aplica los VPC-SC o prefieres el acceso privado, selecciona Privado (Private Service Connect) en el campo Acceso al extremo. De lo contrario, selecciona Público.

    5. Si usas Private Service Connect, ingresa los IDs de tus proyectos en el campo IDs de proyectos, que son los proyectos en los que se ejecutan tus clientes de consultas, o haz clic en Seleccionar IDs de proyectos para mostrar un diálogo que contenga los IDs de proyectos.

      Si haces clic en Seleccionar IDs de proyecto, haz lo siguiente:

      1. Busca tu proyecto que contiene el código que intenta acceder al modelo.
      2. Haz clic en la casilla de verificación de tu proyecto.
      3. Haz clic en Seleccionar.

  5. Haz clic en Implementar.

gcloud CLI

Este comando muestra cómo implementar el modelo en una región específica.

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

En este comando, se muestra cómo implementar el modelo en una región específica con su tipo de máquina, tipo de acelerador y recuento de aceleradores. Si deseas seleccionar una configuración de máquina específica, debes establecer los tres 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)

Como alternativa, no es necesario que pases un parámetro al 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}"'",
  },
}'

Como alternativa, puedes usar la API para establecer de forma explícita el 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
    }
  }
}'

Implementa con la API

Los Controles del servicio de VPC solo funcionan con el extremo privado dedicado. Por lo tanto, debes establecer private_service_connect_config en la siguiente muestra de código, que muestra cómo realizar la implementación con la 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
        }
      }
    }'

Obtén el ID del extremo y el ID del modelo con la consola de Google Cloud

Después de que se complete la implementación, sigue estos pasos:

  1. En la consola de Google Cloud , ve a la página Model Garden.

    Ir a Model Garden

  2. Haz clic en Ver mis extremos y modelos.

  3. En la tabla Mis extremos, verifica el extremo que acabas de implementar en la columna Nombre. Se muestra la página Detalles.

  4. Haz clic en el modelo en la tabla Modelos implementados.

  5. Selecciona la página Detalles de la versión. El ID del modelo se muestra en la fila Variables de entorno de la tabla.

Configura una conexión de Private Service Connect

Estás agregando un nuevo extremo para acceder a las APIs de Google . Este extremo se puede usar en todas las regiones de la red de VPC que selecciones. Además, ten en cuenta lo siguiente:

  • Los clientes en redes conectadas a la red de VPC del extremo a través de la conectividad híbrida pueden acceder al extremo. Para obtener más información, consulta Accede a las APIs deGoogle a través de extremos.
  • Los clientes en redes de VPC con intercambio de tráfico no pueden acceder al extremo.

Extremo de lista para obtener el adjunto de servicio

En esta muestra de código, se muestra cómo enumerar un extremo para obtener una vinculación de servicio.

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 es la respuesta del extremo de la 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"
    ]
  }
}

Crea una conexión de Private Service Connect

Para crear una conexión de Private Service Connect (PSC), sigue estos pasos:

  1. En la consola Google Cloud , ve a la página Private Service Connect. Se mostrará la página Extremos conectados.

    Ir a Private Service Connect

  2. Haz clic en + Conectar extremo. Aparecerá la página Conectar extremo.

  3. Selecciona una opción en el campo Objetivo. Puedes elegir APIs de Google, que proporcionan acceso a la mayoría de las APIs y los servicios, o Servicio publicado, que proporciona acceso a un servicio publicado. Google

  4. En la sección Detalles del destino, selecciona un valor de la lista Alcance y un valor de la lista Tipo de paquete.

  5. En la sección Detalles del extremo, haz lo siguiente:

    1. Escribe un nombre en el campo Nombre del extremo.
    2. Selecciona un valor de la lista Red. Selecciona una red de VPC ubicada en tu proyecto. Si debes crear un extremo de PSC en un proyecto de servicio que usa una red de VPC compartida en un proyecto host, usa Google Cloud CLI o envía una solicitud a la API.
    3. Selecciona un valor de la lista Dirección IP.

  6. Expande la sección Directorio de servicios.

  7. Selecciona una región de la lista Región.

  8. Selecciona un espacio de nombres de la lista Namespace.

  9. Haz clic en Agregar extremo. La tabla Endpoints se actualiza con una fila para tu extremo nuevo.

Cómo hacer una consulta

En esta sección, se explica cómo crear un extremo público y un extremo privado.

Realiza una consulta a un extremo público

Después de implementar tu modelo, los pesos personalizados admiten el extremo público dedicado. Puedes enviar consultas con la API o el SDK.

Antes de enviar consultas, debes obtener la URL del extremo, el ID del extremo y el ID del modelo, que están disponibles en la consola de Google Cloud .

Sigue estos pasos para obtener la información:

  1. En la consola de Google Cloud , ve a la página Model Garden.

    Model Garden

  2. Haz clic en Ver mis extremos y modelos.

  3. Selecciona tu región en la lista Región.

  4. Para obtener el ID y la URL del extremo, haz clic en tu extremo en la sección Mis extremos.

    Tu ID de extremo se muestra en el campo ID de extremo.

    La URL de tu extremo público se muestra en el campo Extremo dedicado.

  5. Para obtener el ID del modelo, busca tu modelo en la sección Modelos implementados y sigue estos pasos:

    1. Haz clic en el nombre del modelo implementado en el campo Modelo.
    2. Haz clic en Detalles de la versión. El ID del modelo se muestra en el campo ID del modelo.

Después de obtener la información del extremo y del modelo implementado, consulta los siguientes ejemplos de código para saber cómo enviar una solicitud de inferencia o consulta Cómo enviar una solicitud de inferencia en línea a un extremo público dedicado.

API

En los siguientes ejemplos de código, se muestran diferentes formas de usar la API según tu caso de uso.

Finalización de chat (unaria)

Esta solicitud de ejemplo envía un mensaje de chat completo al modelo y obtiene una respuesta en un solo fragmento después de que se genera toda la respuesta. Es similar a enviar un mensaje de texto y recibir una sola respuesta 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?"
      }
    ]
  }'

Finalización de chat (transmisión)

Esta solicitud es la versión de transmisión de la solicitud de finalización de chat unaria. Si agregas "stream": true a la solicitud, el modelo enviará su respuesta fragmento por fragmento a medida que se genere. Esto es útil para crear un efecto de máquina de escribir en tiempo real en una aplicación 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?"
      }
    ]
  }'

Predecir

Esta solicitud envía una instrucción directa para obtener una inferencia de un modelo. Esto se suele usar para tareas que no son necesariamente conversacionales, como el resumen o la clasificación 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
      }
    ]
  }'

Raw Predict

Esta solicitud es una versión de transmisión de la solicitud de Predict. Si usas el extremo :streamRawPredict y, además, incluyes "stream": true, esta solicitud envía una instrucción directa y recibe el resultado del modelo como un flujo continuo de datos a medida que se genera, lo que es similar a la solicitud de finalización de chat de transmisión.

  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

En esta muestra de código, se usa el SDK para enviar una búsqueda a un modelo y obtener una respuesta de ese 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)

Realiza una consulta para un extremo privado

Puedes probar tu consulta con un notebook o una VM en el proyecto permitido.

Esta consulta de ejemplo te permite reemplazar variables por tu IP, proyecto, ID de extremo y ID de modelo (que obtuviste en el paso de implementación anterior).

curl

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

Predecir

$ 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 otro ejemplo de cómo usar la API, consulta el notebook Import Custom Weights.

Más información sobre los modelos de implementación propia en Gemini Enterprise Agent Platform