Implementa modelos con pesos personalizados

La implementación de modelos con pesos personalizados es una oferta de versión preliminar. Puedes ajustar los modelos según un conjunto predefinido de modelos de base 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 subiendo los artefactos de tu modelo a un bucket de Cloud Storage en tu proyecto, lo que es una experiencia de un solo clic en Agent Platform.

La compatibilidad de los Controles del servicio de VPC con los pesos personalizados está disponible.

Modelos compatibles

La versión preliminar pública de Implementa modelos con ponderaciones personalizadas es compatible con los siguientes modelos base:

Limitaciones

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

Archivos de modelo

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 modelo, que dependen de la arquitectura del modelo:

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

   Activa Cloud Shell

   En la parte inferior de la consola de Cloud de Confiance , se inicia una sesión de Cloud Shell en la que se muestra una ventana de 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 Cloud de Confiance by S3NS. Si quieres usar un shell diferente en lugar de Cloud Shell, realiza la siguiente configuración adicional:

1. Instala Google Cloud CLI.

2. Configura gcloud CLI para usar tu identidad federada.

   Para obtener más información, consulta Accede a 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: Es tu región. Por ejemplo, uscentral1.
• MODEL_GCS: Es tu modelo de Cloud de Confiance by S3NS . 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.

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

Implementa con la API

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

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

Una vez que se complete la implementación, sigue estos pasos:

1. En la consola de Cloud de Confiance , 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 mostrará 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 Private Service Connect

Estás agregando un nuevo extremo para acceder a las APIs de S3NS . 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 deS3NS a través de extremos.
• Los clientes en redes de VPC de 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 indica cómo enumerar un extremo para obtener un adjunto de servicio.

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

Crea un extremo de Private Service Connect

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

1. En la consola de Cloud de Confiance , ve a la página Private Service Connect. Aparecerá 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 Segmentación. Puedes elegir APIs de Google que proporcionan acceso a la mayoría de las APIs y los servicios de S3NS o Servicio publicado que proporciona acceso a un servicio publicado.

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 Espacio de nombres.

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

Realiza una consulta

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

Realiza una consulta a un extremo público

Después de implementar el modelo, los pesos personalizados admiten el extremo dedicado público. 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 Cloud de Confiance .

Sigue estos pasos para obtener la información:

1. En la consola de Cloud de Confiance , 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.

   El 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 las siguientes muestras de código para saber cómo enviar una solicitud de inferencia o consulta Envía una solicitud de inferencia en línea a un extremo 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)

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 de modelo (obtenido en el paso de implementación anterior)

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 otro ejemplo de cómo usar la API, consulta el notebook Importar pesos personalizados.

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

• Para obtener más información sobre los extremos dedicados privados de predicción en línea de Gemini Enterprise Agent Platform, consulta Usa extremos privados dedicados basados en Private Service Connect para la inferencia en línea.
• Para obtener más información sobre los modelos de implementación propia, consulta Descripción general de los modelos de implementación propia.
• Para obtener más información sobre Model Garden, consulta Descripción general de Model Garden.
• Para obtener más información sobre la implementación de modelos, consulta Usa modelos en Model Garden.
• Usa modelos abiertos de Gemma
• Usa modelos abiertos de Llama
• Usa modelos abiertos de Hugging Face