La implementación de modelos con pesos personalizados es una oferta de 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 Vertex AI. Puedes implementar tus modelos personalizados con la importación de pesos personalizados. Para ello, sube los artefactos del modelo a un bucket de Cloud Storage en tu proyecto, lo que se realiza con un solo clic en Vertex AI.
Ya está disponible la compatibilidad de los Controles del servicio de VPC con los 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 |
|
| Gemma |
|
| Qwen |
|
| Deepseek |
|
| Mistral y Mixtral |
|
| Phi-4 |
|
| OSS de OpenAI |
|
Limitaciones
Los pesos personalizados no admiten la importación de modelos cuantificados.
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 modelos, que dependen de la arquitectura del modelo:
| Contenido del archivo del modelo | Tipo de archivo |
|---|---|
| Configuración del modelo |
|
| Pesos del modelo |
|
| Índice de peso |
|
| Archivos del tokenizador |
|
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
- 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.
-
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 theresourcemanager.projects.createpermission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
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 theserviceusage.services.enablepermission. Learn how to grant roles. -
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 theresourcemanager.projects.createpermission. Learn how to grant roles.
-
Verify that billing is enabled for your Google Cloud project.
-
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 theserviceusage.services.enablepermission. Learn how to grant roles. -
In the Google Cloud console, 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.
-
Install the Google Cloud CLI.
-
If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.
-
To initialize the gcloud CLI, run the following command:
gcloud init - 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: Es el ID de tu 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.
En la consola de Google Cloud , ve a la página Model Garden.
Haz clic en Implementar modelo con pesos personalizados. Aparecerá el panel Implementa un modelo con pesos personalizados.
En la sección Fuente del modelo, haz lo siguiente:
Haz clic en Explorar, elige el bucket en el que se almacena tu modelo y haz clic en Seleccionar.
Opcional: Ingresa el nombre del modelo en el campo Nombre del modelo.
En la sección Configuración de la implementación, haz lo siguiente:
En el campo Región, selecciona tu región y haz clic en Aceptar.
En el campo Especificación de la máquina, selecciona la especificación de la máquina que se usará para implementar tu modelo.
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.
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.
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 IDs de proyectos.
Si haces clic en Seleccionar IDs de proyecto, haz lo siguiente:
- Busca tu proyecto que contiene el código que intenta acceder al modelo.
- Haz clic en la casilla de verificación de tu proyecto.
- Haz clic en Seleccionar.
Haz clic en Implementar.
En la consola de Google Cloud , ve a la página Model Garden.
Haz clic en Ver mis extremos y modelos.
En la tabla Mis extremos, verifica el extremo que acabas de implementar en la columna Nombre. Se muestra la página Detalles.
Haz clic en el modelo en la tabla Modelos implementados.
Selecciona la página Detalles de la versión. El ID del modelo se muestra en la fila Variables de entorno de la tabla.
- 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.
En la consola de Google Cloud , ve a la página Private Service Connect. Aparecerá la página Extremos conectados.
Haz clic en + Conectar extremo. Aparecerá la página Conectar extremo.
Selecciona una opción en el campo Objetivo. Puedes elegir APIs de Google, que proporcionan acceso a la mayoría de las Google APIs y los servicios, o Servicio publicado, que proporciona acceso a un servicio publicado.
En la sección Detalles del destino, selecciona un valor de la lista Alcance y un valor de la lista Tipo de paquete.
En la sección Detalles del extremo, haz lo siguiente:
- Escribe un nombre en el campo Nombre del extremo.
- 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.
- Selecciona un valor de la lista Dirección IP.
Expande la sección Directorio de servicios.
Selecciona una región de la lista Región.
Selecciona un espacio de nombres de la lista Namespace.
Haz clic en Agregar extremo. La tabla Endpoints se actualiza con una fila para tu extremo nuevo.
En la consola de Google Cloud , ve a la página Model Garden.
Haz clic en Ver mis extremos y modelos.
Selecciona tu región en la lista Región.
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.
Para obtener el ID del modelo, busca tu modelo en la sección Modelos implementados y sigue estos pasos:
- Haz clic en el nombre del modelo implementado en el campo Modelo.
- Haz clic en Detalles de la versión. El ID del modelo se muestra en el campo ID del modelo.
- Para obtener más información sobre los extremos privados dedicados de predicción en línea de Vertex AI, 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 la 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
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:
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:
Console
En los siguientes pasos, se muestra cómo usar la consola de Google Cloud para implementar tu modelo con pesos personalizados.
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}
Este comando muestra cómo implementar el modelo en una región específica con su tipo de máquina, tipo de acelerador y cantidad 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 el tipo de máquina de forma explícita.
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 el 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:
Configura una conexión de Private Service Connect
Estás agregando un extremo nuevo 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:
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 endpoint de 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:
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:
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. A menudo, se usa para tareas que no son necesariamente conversacionales, como la clasificación o el resumen 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 Predict. Si usas el extremo :streamRawPredict y, además, incluyes "stream": true, esta solicitud envía una instrucción directa y recibe la respuesta 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 consulta 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.