Esta página se ha traducido con Cloud Translation API.

Obtener inferencias y explicaciones online

En esta página se explica cómo obtener inferencias y explicaciones online (en tiempo real) de tus modelos de clasificación o regresión tabulares mediante la Google Cloud consola o la API de Vertex AI.

Una inferencia online es una solicitud síncrona, a diferencia de la inferencia por lotes, que es una solicitud asíncrona. Usa inferencias online cuando hagas solicitudes en respuesta a la entrada de una aplicación o en otras situaciones en las que necesites inferencias oportunas.

Debes desplegar un modelo en un endpoint para poder usarlo y ofrecer inferencias online. Al desplegar un modelo, se asocian recursos físicos al modelo para que pueda ofrecer inferencias online con baja latencia.

Los temas que se tratan son los siguientes:

Desplegar un modelo en un endpoint
Obtener una inferencia online con el modelo desplegado
Obtener una explicación online con tu modelo desplegado

Antes de empezar

Para obtener inferencias online, primero debes entrenar un modelo de clasificación o regresión y evaluar su precisión.

Desplegar un modelo en un endpoint

Puedes desplegar más de un modelo en un endpoint y desplegar un modelo en más de un endpoint. Para obtener más información sobre las opciones y los casos prácticos de implementación de modelos, consulta el artículo Acerca de la implementación de modelos.

Utilice uno de los siguientes métodos para implementar un modelo:

Google Cloud consola

En la Google Cloud consola, en la sección Vertex AI, ve a la página Modelos.

Ir a la página Modelos
Haz clic en el nombre del modelo que quieras implementar para abrir su página de detalles.
Selecciona la pestaña Implementar y probar.

Si tu modelo ya se ha desplegado en algún endpoint, aparecerá en la sección Desplegar tu modelo.
Haz clic en Implementar en endpoint.
En la página Define your endpoint (Define tu endpoint), configura lo siguiente:
1. Puedes desplegar el modelo en un punto final nuevo o en uno que ya tengas.
  - Para desplegar el modelo en un nuevo endpoint, selecciona Crear endpoint y asigna un nombre al nuevo endpoint.
  - Para desplegar el modelo en un endpoint disponible, selecciona Añadir a endpoint disponible y elige el endpoint en la lista desplegable.
  - Puede añadir más de un modelo a un endpoint y añadir un modelo a más de un endpoint. Más información
2. Haz clic en Continuar.
En la página Configuración del modelo, configure los ajustes de la siguiente manera:
1. Si vas a desplegar el modelo en un endpoint nuevo, acepta el valor 100 en Distribución del tráfico. Si vas a desplegar tu modelo en un punto final que ya tiene uno o varios modelos desplegados, debes actualizar el porcentaje de División del tráfico del modelo que vas a desplegar y de los modelos que ya están desplegados para que todos los porcentajes sumen 100%.
2. Introduce el número mínimo de nodos de computación que quieras proporcionar para tu modelo.
  
  Es el número de nodos disponibles para este modelo en todo momento. Se te cobrará por los nodos utilizados, ya sea para gestionar la carga de inferencia o para los nodos de reserva (mínimo), incluso si no hay tráfico de inferencia. Consulta la página de precios.
3. Selecciona el Tipo de máquina.
  
  Cuanto mayores sean los recursos de la máquina, mejor será el rendimiento de la inferencia y mayores serán los costes.
4. Consulta cómo cambiar la configuración predeterminada del registro de inferencias.
5. Haz clic en Continuar.
En la página Monitorización de modelos, haz clic en Continuar.
En la página Objetivos de monitorización, configure lo siguiente:
1. Introduce la ubicación de tus datos de entrenamiento.
2. Escribe el nombre de la columna de destino.
Haga clic en Desplegar para desplegar el modelo en el endpoint.

API

Cuando despliegas un modelo con la API de Vertex AI, sigues estos pasos:

Crea un endpoint si es necesario.
Obtén el ID del endpoint.
Despliega el modelo en el endpoint.

Crear un punto final

Si vas a desplegar un modelo en un endpoint que ya tienes, puedes saltarte este paso.

gcloud

En el siguiente ejemplo se usa el comando gcloud ai endpoints create:

  gcloud ai endpoints create \
    --region=LOCATION \
    --display-name=ENDPOINT_NAME

Haz los cambios siguientes:

LOCATION_ID: la región en la que usas Vertex AI.
ENDPOINT_NAME: el nombre visible del endpoint.

La herramienta de Google Cloud CLI puede tardar unos segundos en crear el endpoint.

REST

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION_ID: tu región.
PROJECT_ID: tu ID de proyecto.
ENDPOINT_NAME: el nombre visible del endpoint.

Método HTTP y URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints

Cuerpo JSON de la solicitud:

{
  "display_name": "ENDPOINT_NAME"
}

Para enviar tu solicitud, despliega una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Nota: En el siguiente comando se presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login , o bien usando Cloud Shell, que inicia sesión automáticamente en la CLI de gcloud . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints"

PowerShell (Windows)

Nota: El siguiente comando presupone que has iniciado sesión en la CLI de gcloud con tu cuenta de usuario ejecutando gcloud init o gcloud auth login . Para comprobar qué cuenta está activa, ejecuta gcloud auth list.

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.CreateEndpointOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-11-05T17:45:42.812656Z",
      "updateTime": "2020-11-05T17:45:42.812656Z"
    }
  }
}

Puedes sondear el estado de la operación hasta que la respuesta incluya "done": true.

Java

Antes de probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.CreateEndpointOperationMetadata;
import com.google.cloud.aiplatform.v1.Endpoint;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateEndpointSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String endpointDisplayName = "YOUR_ENDPOINT_DISPLAY_NAME";
    createEndpointSample(project, endpointDisplayName);
  }

  static void createEndpointSample(String project, String endpointDisplayName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (EndpointServiceClient endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);
      Endpoint endpoint = Endpoint.newBuilder().setDisplayName(endpointDisplayName).build();

      OperationFuture<Endpoint, CreateEndpointOperationMetadata> endpointFuture =
          endpointServiceClient.createEndpointAsync(locationName, endpoint);
      System.out.format("Operation name: %s\n", endpointFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      Endpoint endpointResponse = endpointFuture.get(300, TimeUnit.SECONDS);

      System.out.println("Create Endpoint Response");
      System.out.format("Name: %s\n", endpointResponse.getName());
      System.out.format("Display Name: %s\n", endpointResponse.getDisplayName());
      System.out.format("Description: %s\n", endpointResponse.getDescription());
      System.out.format("Labels: %s\n", endpointResponse.getLabelsMap());
      System.out.format("Create Time: %s\n", endpointResponse.getCreateTime());
      System.out.format("Update Time: %s\n", endpointResponse.getUpdateTime());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Vertex AI.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const endpointDisplayName = 'YOUR_ENDPOINT_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Endpoint Service Client library
const {EndpointServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function createEndpoint() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const endpoint = {
    displayName: endpointDisplayName,
  };
  const request = {
    parent,
    endpoint,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.createEndpoint(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  const result = response.result;

  console.log('Create endpoint response');
  console.log(`\tName : ${result.name}`);
  console.log(`\tDisplay name : ${result.displayName}`);
  console.log(`\tDescription : ${result.description}`);
  console.log(`\tLabels : ${JSON.stringify(result.labels)}`);
  console.log(`\tCreate time : ${JSON.stringify(result.createTime)}`);
  console.log(`\tUpdate time : ${JSON.stringify(result.updateTime)}`);
}
createEndpoint();

Python

Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la API Python.

def create_endpoint_sample(
    project: str,
    display_name: str,
    location: str,
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint.create(
        display_name=display_name,
        project=project,
        location=location,
    )

    print(endpoint.display_name)
    print(endpoint.resource_name)
    return endpoint

Obtener el ID del endpoint

Necesitas el ID del endpoint para desplegar el modelo.

gcloud

En el siguiente ejemplo se usa el comando gcloud ai endpoints list:

  gcloud ai endpoints list \
    --region=LOCATION \
    --filter=display_name=ENDPOINT_NAME

Haz los cambios siguientes:

LOCATION_ID: la región en la que usas Vertex AI.
ENDPOINT_NAME: el nombre visible del endpoint.

Fíjate en el número que aparece en la columna ENDPOINT_ID. Úsalo en el paso siguiente.

REST

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION_ID: la región en la que usas Vertex AI.
PROJECT_ID: .
ENDPOINT_NAME: el nombre visible del endpoint.

Método HTTP y URL:

GET https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME

Para enviar tu solicitud, despliega una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Ejecuta el comando siguiente:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME"

PowerShell (Windows)

Ejecuta el comando siguiente:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "endpoints": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID",
      "displayName": "ENDPOINT_NAME",
      "etag": "AMEw9yPz5pf4PwBHbRWOGh0PcAxUdjbdX2Jm3QO_amguy3DbZGP5Oi_YUKRywIE-BtLx",
      "createTime": "2020-04-17T18:31:11.585169Z",
      "updateTime": "2020-04-17T18:35:08.568959Z"
    }
  ]
}

Ten en cuenta el ENDPOINT_ID.

Desplegar el modelo

Selecciona la pestaña correspondiente a tu idioma o entorno:

gcloud

En los siguientes ejemplos se usa el comando gcloud ai endpoints deploy-model.

En el siguiente ejemplo se implementa un Model en un Endpoint sin usar GPUs para acelerar el servicio de predicciones y sin dividir el tráfico entre varios recursos DeployedModel:

Antes de usar los datos de los comandos que se indican a continuación, haz los siguientes cambios:

ENDPOINT_ID: ID del endpoint.
LOCATION_ID: la región en la que usas Vertex AI.
MODEL_ID: ID del modelo que se va a implementar.
DEPLOYED_MODEL_NAME: nombre del DeployedModel. También puedes usar el nombre visible de la Model para la DeployedModel.
MACHINE_TYPE: opcional. Los recursos de la máquina que se usan en cada nodo de esta implementación. Su ajuste predeterminado es n1-standard-2. Más información sobre los tipos de máquinas
MIN_REPLICA_COUNT: número mínimo de nodos de esta implementación. El número de nodos se puede aumentar o reducir según lo requiera la carga de inferencia, hasta el número máximo de nodos y nunca por debajo de este número. Este valor debe ser superior o igual a 1. Si se omite la marca --min-replica-count, el valor predeterminado es 1.
MAX_REPLICA_COUNT: número máximo de nodos de este despliegue. El número de nodos se puede aumentar o reducir según lo requiera la carga de inferencia, hasta este número de nodos y nunca por debajo del número mínimo de nodos. Si omite la marca --max-replica-count, el número máximo de nodos se define como el valor de --min-replica-count.

Ejecuta el comando gcloud ai endpoints deploy-model:

Linux, macOS o Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --machine-type=MACHINE_TYPE \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=100

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME `
  --machine-type=MACHINE_TYPE `
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=100

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME ^
  --machine-type=MACHINE_TYPE ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=100

Dividir el tráfico

La marca --traffic-split=0=100 de los ejemplos anteriores envía el 100% del tráfico de predicción que recibe Endpoint al nuevo DeployedModel, que se representa con el ID temporal 0. Si tu Endpoint ya tiene otros DeployedModel recursos, puedes dividir el tráfico entre los nuevos DeployedModel y los antiguos. Por ejemplo, para enviar el 20% del tráfico a la nueva DeployedModel y el 80% a una anterior, ejecuta el siguiente comando.

Antes de usar los datos de los comandos que se indican a continuación, haz los siguientes cambios:

OLD_DEPLOYED_MODEL_ID: el ID del DeployedModel.

Ejecuta el comando gcloud ai endpoints deploy-model:

Linux, macOS o Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \ 
  --machine-type=MACHINE_TYPE \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME \ 
  --machine-type=MACHINE_TYPE `
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME \ 
  --machine-type=MACHINE_TYPE ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

REST

Para solicitar una inferencia online, se usa el método endpoints.predict.

Despliega el modelo.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION_ID: la región en la que usas Vertex AI.
PROJECT_ID: .
ENDPOINT_ID: ID del endpoint.
MODEL_ID: ID del modelo que se va a implementar.
DEPLOYED_MODEL_NAME: nombre del DeployedModel. También puedes usar el nombre visible de la Model para la DeployedModel.
MACHINE_TYPE: opcional. Los recursos de la máquina que se usan en cada nodo de esta implementación. Su ajuste predeterminado es n1-standard-2. Más información sobre los tipos de máquinas
ACCELERATOR_TYPE: tipo de acelerador que se va a asociar a la máquina. Opcional si ACCELERATOR_COUNT no se especifica o es cero. No se recomienda para modelos de AutoML ni modelos entrenados personalizados que usen imágenes que no sean de GPU. Más información
ACCELERATOR_COUNT: número de aceleradores que debe usar cada réplica. Opcional. Debe ser cero o no especificarse en los modelos de AutoML o en los modelos entrenados personalizados que usen imágenes que no sean de GPU.
MIN_REPLICA_COUNT: número mínimo de nodos de esta implementación. El número de nodos se puede aumentar o reducir según lo requiera la carga de inferencia, hasta el número máximo de nodos y nunca por debajo de este número. Este valor debe ser superior o igual a 1.
MAX_REPLICA_COUNT: número máximo de nodos de este despliegue. El número de nodos se puede aumentar o reducir según lo requiera la carga de inferencia, hasta este número de nodos y nunca por debajo del número mínimo de nodos.
REQUIRED_REPLICA_COUNT: opcional. Número de nodos necesarios para que esta implementación se marque como correcta. Debe ser igual o superior a 1 e igual o inferior al número mínimo de nodos. Si no se especifica, el valor predeterminado es el número mínimo de nodos.
TRAFFIC_SPLIT_THIS_MODEL: porcentaje del tráfico de predicción de este punto final que se va a dirigir al modelo que se está desplegando con esta operación. El valor predeterminado es 100. Todos los porcentajes de tráfico deben sumar 100. Más información sobre las divisiones de tráfico
DEPLOYED_MODEL_ID_N: opcional. Si se implementan otros modelos en este endpoint, debes actualizar los porcentajes de división del tráfico para que todos los porcentajes sumen 100.
TRAFFIC_SPLIT_MODEL_N: valor del porcentaje de división del tráfico de la clave del ID del modelo implementado.
PROJECT_NUMBER: el número de proyecto generado automáticamente de tu proyecto

Método HTTP y URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel

Cuerpo JSON de la solicitud:

{
  "deployedModel": {
    "model": "projects/PROJECT/locations/us-central1/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_NAME",
    "dedicatedResources": {
       "machineSpec": {
         "machineType": "MACHINE_TYPE",
         "acceleratorType": "ACCELERATOR_TYPE",
         "acceleratorCount": "ACCELERATOR_COUNT"
       },
       "minReplicaCount": MIN_REPLICA_COUNT,
       "maxReplicaCount": MAX_REPLICA_COUNT,
       "requiredReplicaCount": REQUIRED_REPLICA_COUNT
     },
  },
  "trafficSplit": {
    "0": TRAFFIC_SPLIT_THIS_MODEL,
    "DEPLOYED_MODEL_ID_1": TRAFFIC_SPLIT_MODEL_1,
    "DEPLOYED_MODEL_ID_2": TRAFFIC_SPLIT_MODEL_2
  },
}

Para enviar tu solicitud, despliega una de estas opciones:

curl (Linux, macOS o Cloud Shell)

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel"

PowerShell (Windows)

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-19T17:53:16.502088Z",
      "updateTime": "2020-10-19T17:53:16.502088Z"
    }
  }
}

Java

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.DedicatedResources;
import com.google.cloud.aiplatform.v1.DeployModelOperationMetadata;
import com.google.cloud.aiplatform.v1.DeployModelResponse;
import com.google.cloud.aiplatform.v1.DeployedModel;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;

public class DeployModelCustomTrainedModelSample {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String endpointId = "ENDPOINT_ID";
    String modelName = "MODEL_NAME";
    String deployedModelDisplayName = "DEPLOYED_MODEL_DISPLAY_NAME";
    deployModelCustomTrainedModelSample(project, endpointId, modelName, deployedModelDisplayName);
  }

  static void deployModelCustomTrainedModelSample(
      String project, String endpointId, String model, String deployedModelDisplayName)
      throws IOException, ExecutionException, InterruptedException {
    EndpointServiceSettings settings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (EndpointServiceClient client = EndpointServiceClient.create(settings)) {
      MachineSpec machineSpec = MachineSpec.newBuilder().setMachineType("n1-standard-2").build();
      DedicatedResources dedicatedResources =
          DedicatedResources.newBuilder().setMinReplicaCount(1).setMachineSpec(machineSpec).build();

      String modelName = ModelName.of(project, location, model).toString();
      DeployedModel deployedModel =
          DeployedModel.newBuilder()
              .setModel(modelName)
              .setDisplayName(deployedModelDisplayName)
              // `dedicated_resources` must be used for non-AutoML models
              .setDedicatedResources(dedicatedResources)
              .build();
      // key '0' assigns traffic for the newly deployed model
      // Traffic percentage values must add up to 100
      // Leave dictionary empty if endpoint should not accept any traffic
      Map<String, Integer> trafficSplit = new HashMap<>();
      trafficSplit.put("0", 100);
      EndpointName endpoint = EndpointName.of(project, location, endpointId);
      OperationFuture<DeployModelResponse, DeployModelOperationMetadata> response =
          client.deployModelAsync(endpoint, deployedModel, trafficSplit);

      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Operation name: %s\n", response.getInitialFuture().get().getName());

      // OperationFuture.get() will block until the operation is finished.
      DeployModelResponse deployModelResponse = response.get();
      System.out.format("deployModelResponse: %s\n", deployModelResponse);
    }
  }
}

Python

def deploy_model_with_dedicated_resources_sample(
    project,
    location,
    model_name: str,
    machine_type: str,
    endpoint: Optional[aiplatform.Endpoint] = None,
    deployed_model_display_name: Optional[str] = None,
    traffic_percentage: Optional[int] = 0,
    traffic_split: Optional[Dict[str, int]] = None,
    min_replica_count: int = 1,
    max_replica_count: int = 1,
    accelerator_type: Optional[str] = None,
    accelerator_count: Optional[int] = None,
    explanation_metadata: Optional[explain.ExplanationMetadata] = None,
    explanation_parameters: Optional[explain.ExplanationParameters] = None,
    metadata: Optional[Sequence[Tuple[str, str]]] = (),
    sync: bool = True,
):
    """
    model_name: A fully-qualified model resource name or model ID.
          Example: "projects/123/locations/us-central1/models/456" or
          "456" when project and location are initialized or passed.
    """

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

    model = aiplatform.Model(model_name=model_name)

    # The explanation_metadata and explanation_parameters should only be
    # provided for a custom trained model and not an AutoML model.
    model.deploy(
        endpoint=endpoint,
        deployed_model_display_name=deployed_model_display_name,
        traffic_percentage=traffic_percentage,
        traffic_split=traffic_split,
        machine_type=machine_type,
        min_replica_count=min_replica_count,
        max_replica_count=max_replica_count,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        explanation_metadata=explanation_metadata,
        explanation_parameters=explanation_parameters,
        metadata=metadata,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    return model

Node.js

const automl = require('@google-cloud/automl');
const client = new automl.v1beta1.AutoMlClient();

/**
 * Demonstrates using the AutoML client to create a model.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const datasetId = '[DATASET_ID]' e.g., "TBL2246891593778855936";
// const tableId = '[TABLE_ID]' e.g., "1991013247762825216";
// const columnId = '[COLUMN_ID]' e.g., "773141392279994368";
// const modelName = '[MODEL_NAME]' e.g., "testModel";
// const trainBudget = '[TRAIN_BUDGET]' e.g., "1000",
// `Train budget in milli node hours`;

// A resource that represents Google Cloud Platform location.
const projectLocation = client.locationPath(projectId, computeRegion);

// Get the full path of the column.
const columnSpecId = client.columnSpecPath(
  projectId,
  computeRegion,
  datasetId,
  tableId,
  columnId
);

// Set target column to train the model.
const targetColumnSpec = {name: columnSpecId};

// Set tables model metadata.
const tablesModelMetadata = {
  targetColumnSpec: targetColumnSpec,
  trainBudgetMilliNodeHours: trainBudget,
};

// Set datasetId, model name and model metadata for the dataset.
const myModel = {
  datasetId: datasetId,
  displayName: modelName,
  tablesModelMetadata: tablesModelMetadata,
};

// Create a model with the model metadata in the region.
client
  .createModel({parent: projectLocation, model: myModel})
  .then(responses => {
    const initialApiResponse = responses[1];
    console.log(`Training operation name: ${initialApiResponse.name}`);
    console.log('Training started...');
  })
  .catch(err => {
    console.error(err);
  });

Consulta cómo cambiar la configuración predeterminada del registro de inferencias.

Obtener el estado de la operación

Algunas solicitudes inician operaciones de larga duración que requieren tiempo para completarse. Estas solicitudes devuelven un nombre de operación que puedes usar para ver el estado de la operación o cancelarla. Vertex AI proporciona métodos auxiliares para hacer llamadas a operaciones de larga duración. Para obtener más información, consulta Trabajar con operaciones de larga duración.

Obtener una inferencia online con el modelo desplegado

Para hacer una inferencia online, envía uno o varios elementos de prueba a un modelo para que los analice. El modelo devuelve resultados basados en el objetivo del modelo. Usa la Google Cloud consola o la API de Vertex AI para solicitar una inferencia online.

Google Cloud consola

En la Google Cloud consola, en la sección Vertex AI, ve a la página Modelos.

Ir a la página Modelos
En la lista de modelos, haz clic en el nombre del modelo del que quieras solicitar inferencias.
Selecciona la pestaña Implementar y probar.
En la sección Prueba tu modelo, añade elementos de prueba para solicitar una inferencia. Los datos de inferencia de referencia se rellenan automáticamente, pero también puedes introducir tus propios datos de inferencia y hacer clic en Predecir.

Una vez completada la inferencia, Vertex AI devuelve los resultados en la consola.

API: Classification

gcloud

Crea un archivo llamado request.json con el siguiente contenido:
```
      {
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}
    
```
Haz los cambios siguientes:
- PREDICTION_DATA_ROW: objeto JSON con las claves como nombres de las funciones y los valores como los valores de las funciones correspondientes. Por ejemplo, en un conjunto de datos con un número, un array de cadenas y una categoría, la fila de datos podría tener el siguiente aspecto:
```
"length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]
```
  Se debe proporcionar un valor para cada función incluida en la formación. El formato de los datos usados para la predicción debe coincidir con el formato usado para el entrenamiento. Consulta los detalles en Formato de datos para las predicciones.
Ejecuta el siguiente comando:
```
gcloud ai endpoints predict ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json
```
Haz los cambios siguientes:
- ENDPOINT_ID: ID del endpoint.
- LOCATION_ID: la región en la que usas Vertex AI.

REST

Para solicitar una inferencia online, se usa el método endpoints.predict.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION_ID: región en la que se encuentra el endpoint. Por ejemplo, us-central1.
PROJECT_ID: tu ID de proyecto.
ENDPOINT_ID: ID del endpoint.
PREDICTION_DATA_ROW: objeto JSON con las claves como nombres de las funciones y los valores como los valores de las funciones correspondientes. Por ejemplo, en un conjunto de datos con un número, un array de cadenas y una categoría, la fila de datos podría tener el siguiente aspecto:
```
"length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]
```
Se debe proporcionar un valor para cada función incluida en la formación. El formato de los datos usados para la predicción debe coincidir con el formato usado para el entrenamiento. Consulta los detalles en Formato de datos para las predicciones.
DEPLOYED_MODEL_ID: salida del método predict y aceptado como entrada por el método explain. El ID del modelo usado para generar la inferencia. Si necesitas solicitar explicaciones de una inferencia que ya has solicitado y tienes más de un modelo implementado, puedes usar este ID para asegurarte de que las explicaciones se devuelvan para el mismo modelo que proporcionó la inferencia anterior.

Método HTTP y URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:predict

Cuerpo JSON de la solicitud:

{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:predict"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:predict" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:

   {
     "predictions": [
      {
         "scores": [
           0.96771615743637085,
           0.032283786684274673
         ],
         "classes": [
           "0",
           "1"
         ]
      }
     ]
     "deployedModelId": "2429510197"
   }

Java


import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.cloud.aiplatform.v1.schema.predict.prediction.TabularClassificationPredictionResult;
import com.google.protobuf.ListValue;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.List;

public class PredictTabularClassificationSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String instance = "[{ “feature_column_a”: “value”, “feature_column_b”: “value”}]";
    String endpointId = "YOUR_ENDPOINT_ID";
    predictTabularClassification(instance, project, endpointId);
  }

  static void predictTabularClassification(String instance, String project, String endpointId)
      throws IOException {
    PredictionServicPredictionServiceSettingsceSettings =
        PredictionServicPredictionServiceSettings          .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PredictionServicPredictionServiceClientceClient =
        PredictionServicPredictionServiceClientonServiceSettings)) {
      String location = "us-central1";
      EndpointName endEndpointNameEndpointName.of(EndpointNameation, endpointId);

      ListValue.BuildeListValueue = ListValue.newBuiListValue     JsonFormat.parseJsonFormatinstance, listValue);
      List<Value> instanListValuelistValue.getValuesList();

      Value parametersValuelue.newBuilderValuetListValue(listValue).build();
      PredictResponse PredictResponse =
          predictionServiceClient.predict(endpointName, instanceList, parameters);
      System.out.println("Predict Tabular Classification Response");
      System.out.format("\tDeployed Model Id: %s\n", predictResponse.predictResponse.getDeployedModelId().out.println("Predictions");
      for (Value predictionValueedictResponse.predictResponse.getPredictionsList()larClassificTabularClassificationPredictionResultuilder =
            TabularClassificTabularClassificationPredictionResult       TabularClassificTabularClassificationPredictionResult      (TabularClassificTabularClassificationPredictionResult  ValueConverter.fValueConvertertBuilder, prediction);

        for (int i = 0; i < result.getClasseresult.getClassesCount()   System.out.printf("\tClass: %s", result.getClasseresult.getClasses(i)tem.out.printf("\tScore: %f", result.getScoresresult.getScores(i)   }
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const endpointId = 'YOUR_ENDPOINT_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {prediction} =
  aiplatform.protos.google.cloud.aiplatform.v1.schema.predict;

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function predictTablesClassification() {
  // Configure the endpoint resource
  const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;
  const parameters = helpers.toValue({});

  const instance = helpers.toValue({
    petal_length: '1.4',
    petal_width: '1.3',
    sepal_length: '5.1',
    sepal_width: '2.8',
  });

  const instances = [instance];
  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);

  console.log('Predict tabular classification response');
  console.log(`\tDeployed model id : ${response.deployedModelId}\n`);
  const predictions = response.predictions;
  console.log('Predictions :');
  for (const predictionResultVal of predictions) {
    const predictionResultObj =
      prediction.TabularClassificationPredictionResult.fromValue(
        predictionResultVal
      );
    for (const [i, class_] of predictionResultObj.classes.entries()) {
      console.log(`\tClass: ${class_}`);
      console.log(`\tScore: ${predictionResultObj.scores[i]}\n\n`);
    }
  }
}
predictTablesClassification();

Python

def predict_tabular_classification_sample(
    project: str,
    location: str,
    endpoint_name: str,
    instances: List[Dict],
):
    """
    Args
        project: Your project ID or project number.
        location: Region where Endpoint is located. For example, 'us-central1'.
        endpoint_name: A fully qualified endpoint name or endpoint ID. Example: "projects/123/locations/us-central1/endpoints/456" or
               "456" when project and location are initialized or passed.
        instances: A list of one or more instances (examples) to return a prediction for.
    """
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint(endpoint_name)

    response = endpoint.predict(instances=instances)

    for prediction_ in response.predictions:
        print(prediction_)

API: regresión

gcloud

Crea un archivo llamado `request.json` con el siguiente contenido:
```
      {
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}
    
```
Haz los cambios siguientes:
- PREDICTION_DATA_ROW: objeto JSON con las claves como nombres de las funciones y los valores como los valores de las funciones correspondientes. Por ejemplo, en un conjunto de datos con un número, un array de números y una categoría, la fila de datos podría tener el siguiente aspecto:
```
"age":3.6,
"sq_ft":5392,
"code": "90331"
```
  Se debe proporcionar un valor para cada función incluida en la formación. El formato de los datos usados para la predicción debe coincidir con el formato usado para el entrenamiento. Consulta los detalles en Formato de datos para las predicciones.
Ejecuta el siguiente comando:
```
gcloud ai endpoints predict ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json
```
Haz los cambios siguientes:
- ENDPOINT_ID: ID del endpoint.
- LOCATION_ID: la región en la que usas Vertex AI.

REST

Para solicitar una inferencia online, se usa el método endpoints.predict.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION_ID: región en la que se encuentra el endpoint. Por ejemplo, us-central1.
PROJECT_ID: .
ENDPOINT_ID: ID del endpoint.
PREDICTION_DATA_ROW: objeto JSON con las claves como nombres de las funciones y los valores como los valores de las funciones correspondientes. Por ejemplo, en un conjunto de datos con un número, un array de números y una categoría, la fila de datos podría tener el siguiente aspecto:
```
"age":3.6,
"sq_ft":5392,
"code": "90331"
```
Se debe proporcionar un valor para cada función incluida en la formación. El formato de los datos usados para la predicción debe coincidir con el formato usado para el entrenamiento. Consulta los detalles en Formato de datos para las predicciones.
DEPLOYED_MODEL_ID: salida del método predict y aceptado como entrada por el método explain. El ID del modelo usado para generar la inferencia. Si necesitas solicitar explicaciones de una inferencia que ya has solicitado y tienes más de un modelo implementado, puedes usar este ID para asegurarte de que las explicaciones se devuelvan para el mismo modelo que proporcionó la inferencia anterior.

Método HTTP y URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:predict

Cuerpo JSON de la solicitud:

{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:predict"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:predict" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la siguiente:


{
  "predictions": [
    [
      {
        "value": 65.14233,
        "lower_bound": 4.6572,
        "upper_bound": 164.0279
      }
    ]
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

Java


import com.google.cloud.aiplatform.util.ValueConverter;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.cloud.aiplatform.v1.schema.predict.prediction.TabularRegressionPredictionResult;
import com.google.protobuf.ListValue;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.List;

public class PredictTabularRegressionSample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String instance = "[{ “feature_column_a”: “value”, “feature_column_b”: “value”}]";
    String endpointId = "YOUR_ENDPOINT_ID";
    predictTabularRegression(instance, project, endpointId);
  }

  static void predictTabularRegression(String instance, String project, String endpointId)
      throws IOException {
    PredictionServicPredictionServiceSettingsceSettings =
        PredictionServicPredictionServiceSettings          .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PredictionServicPredictionServiceClientceClient =
        PredictionServicPredictionServiceClientonServiceSettings)) {
      String location = "us-central1";
      EndpointName endEndpointNameEndpointName.of(EndpointNameation, endpointId);

      ListValue.BuildeListValueue = ListValue.newBuiListValue     JsonFormat.parseJsonFormatinstance, listValue);
      List<Value> instanListValuelistValue.getValuesList();

      Value parametersValuelue.newBuilderValuetListValue(listValue).build();
      PredictResponse PredictResponse =
          predictionServiceClient.predict(endpointName, instanceList, parameters);
      System.out.println("Predict Tabular Regression Response");
      System.out.format("\tDisplay Model Id: %s\n", predictResponse.predictResponse.getDeployedModelId().out.println("Predictions");
      for (Value predictionValueedictResponse.predictResponse.getPredictionsList()larRegressioTabularRegressionPredictionResultuilder =
            TabularRegressioTabularRegressionPredictionResult        TabularRegressioTabularRegressionPredictionResult      (TabularRegressioTabularRegressionPredictionResult.fValueConvertertBuilder, prediction);

        System.out.printf("\tUpper bound: %f\n", result.getUpperBresult.getUpperBound()m.out.printf("\tLower bound: %f\n", result.getLowerBresult.getLowerBound()m.out.printf("\tValue: %f\n", result.getValue(result.getValue()
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const endpointId = 'YOUR_ENDPOINT_ID';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';
const aiplatform = require('@google-cloud/aiplatform');
const {prediction} =
  aiplatform.protos.google.cloud.aiplatform.v1.schema.predict;

// Imports the Google Cloud Prediction service client
const {PredictionServiceClient} = aiplatform.v1;

// Import the helper module for converting arbitrary protobuf.Value objects.
const {helpers} = aiplatform;

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const predictionServiceClient = new PredictionServiceClient(clientOptions);

async function predictTablesRegression() {
  // Configure the endpoint resource
  const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;
  const parameters = helpers.toValue({});

  // TODO (erschmid): Make this less painful
  const instance = helpers.toValue({
    BOOLEAN_2unique_NULLABLE: false,
    DATETIME_1unique_NULLABLE: '2019-01-01 00:00:00',
    DATE_1unique_NULLABLE: '2019-01-01',
    FLOAT_5000unique_NULLABLE: 1611,
    FLOAT_5000unique_REPEATED: [2320, 1192],
    INTEGER_5000unique_NULLABLE: '8',
    NUMERIC_5000unique_NULLABLE: 16,
    STRING_5000unique_NULLABLE: 'str-2',
    STRUCT_NULLABLE: {
      BOOLEAN_2unique_NULLABLE: false,
      DATE_1unique_NULLABLE: '2019-01-01',
      DATETIME_1unique_NULLABLE: '2019-01-01 00:00:00',
      FLOAT_5000unique_NULLABLE: 1308,
      FLOAT_5000unique_REPEATED: [2323, 1178],
      FLOAT_5000unique_REQUIRED: 3089,
      INTEGER_5000unique_NULLABLE: '1777',
      NUMERIC_5000unique_NULLABLE: 3323,
      TIME_1unique_NULLABLE: '23:59:59.999999',
      STRING_5000unique_NULLABLE: 'str-49',
      TIMESTAMP_1unique_NULLABLE: '1546387199999999',
    },
    TIMESTAMP_1unique_NULLABLE: '1546387199999999',
    TIME_1unique_NULLABLE: '23:59:59.999999',
  });

  const instances = [instance];
  const request = {
    endpoint,
    instances,
    parameters,
  };

  // Predict request
  const [response] = await predictionServiceClient.predict(request);

  console.log('Predict tabular regression response');
  console.log(`\tDeployed model id : ${response.deployedModelId}`);
  const predictions = response.predictions;
  console.log('\tPredictions :');
  for (const predictionResultVal of predictions) {
    const predictionResultObj =
      prediction.TabularRegressionPredictionResult.fromValue(
        predictionResultVal
      );
    console.log(`\tUpper bound: ${predictionResultObj.upper_bound}`);
    console.log(`\tLower bound: ${predictionResultObj.lower_bound}`);
    console.log(`\tLower bound: ${predictionResultObj.value}`);
  }
}
predictTablesRegression();

Python

def predict_tabular_regression_sample(
    project: str,
    location: str,
    endpoint_name: str,
    instances: List[Dict],
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint(endpoint_name)

    response = endpoint.predict(instances=instances)

    for prediction_ in response.predictions:
        print(prediction_)

Interpretar los resultados de las predicciones

Clasificación

Los modelos de clasificación devuelven una puntuación de confianza.

La puntuación de confianza indica la intensidad con la que tu modelo asocia cada clase o etiqueta con un elemento de prueba. Cuanto mayor sea el número, mayor será la confianza del modelo en que la etiqueta se debe aplicar a ese elemento. Tú decides lo alto que debe ser el nivel de confianza para aceptar los resultados del modelo.

Regresión

Los modelos de regresión devuelven un valor de inferencia. En el caso de los destinos de BigQuery, también devuelven un intervalo de inferencia. El intervalo de inferencia proporciona un intervalo de valores que el modelo tiene una confianza del 95% de que contiene el resultado real.

Obtener una explicación online con tu modelo desplegado

Puedes solicitar una inferencia con explicaciones (también llamadas atribuciones de características) para ver cómo ha llegado tu modelo a una inferencia. Los valores de importancia de las funciones locales te indican cuánto ha contribuido cada función al resultado de la inferencia. Las atribuciones de funciones se incluyen en las inferencias de Vertex AI a través de Vertex Explainable AI.

Consola

Cuando usas la Google Cloud consola para solicitar una inferencia online, se devuelven automáticamente los valores de importancia de las funciones locales.

Si ha usado los valores de predicción rellenados previamente, todos los valores de importancia de las funciones locales serán cero. Esto se debe a que los valores rellenados previamente son los datos de predicción de referencia, por lo que la predicción devuelta es el valor de predicción de referencia.

gcloud

Crea un archivo llamado request.json con el siguiente contenido:
```
{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ]
}
```
Haz los cambios siguientes:
- PREDICTION_DATA_ROW: objeto JSON con las claves como nombres de las funciones y los valores como los valores de las funciones correspondientes. Por ejemplo, en un conjunto de datos con un número, un array de cadenas y una categoría, la fila de datos podría tener el siguiente aspecto:
```
"length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]
```
  Se debe proporcionar un valor para cada función incluida en la formación. El formato de los datos usados para la predicción debe coincidir con el formato usado para el entrenamiento. Consulta los detalles en Formato de datos para las predicciones.
Ejecuta el siguiente comando:
```
gcloud ai endpoints explain ENDPOINT_ID \
  --region=LOCATION_ID \
  --json-request=request.json
```
Haz los cambios siguientes:
- ENDPOINT_ID: ID del endpoint.
- LOCATION_ID: la región en la que usas Vertex AI.
De forma opcional, si quieres enviar una solicitud de explicación a un DeployedModel específico de la Endpoint, puedes especificar la marca --deployed-model-id:
```
gcloud ai endpoints explain ENDPOINT_ID \
  --region=LOCATION \
  --deployed-model-id=DEPLOYED_MODEL_ID \
  --json-request=request.json
```
Además de los marcadores de posición descritos anteriormente, sustituya lo siguiente:
- DEPLOYED_MODEL_ID Opcional: ID del modelo implementado del que quiere obtener explicaciones. El ID se incluye en la respuesta del método predict. Si necesitas solicitar explicaciones de un modelo concreto y tienes más de un modelo desplegado en el mismo endpoint, puedes usar este ID para asegurarte de que las explicaciones se devuelvan para ese modelo concreto.

REST

En el siguiente ejemplo se muestra una solicitud de inferencia online para un modelo de clasificación tabular con atribuciones de características locales. El formato de la solicitud es el mismo para los modelos de regresión.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

LOCATION: región en la que se encuentra el endpoint. Por ejemplo, us-central1.
PROJECT: .
ENDPOINT_ID: ID del endpoint.
PREDICTION_DATA_ROW: objeto JSON con las claves como nombres de las funciones y los valores como los valores de las funciones correspondientes. Por ejemplo, en un conjunto de datos con un número, un array de cadenas y una categoría, la fila de datos podría tener el siguiente aspecto:
```
"length":3.6,
"material":"cotton",
"tag_array": ["abc","def"]
```
Se debe proporcionar un valor para cada función incluida en la formación. El formato de los datos usados para la predicción debe coincidir con el formato usado para el entrenamiento. Consulta los detalles en Formato de datos para las predicciones.
DEPLOYED_MODEL_ID (opcional): ID del modelo implementado del que quiere obtener explicaciones. El ID se incluye en la respuesta del método predict. Si necesitas solicitar explicaciones de un modelo concreto y tienes más de un modelo desplegado en el mismo endpoint, puedes usar este ID para asegurarte de que las explicaciones se devuelvan para ese modelo concreto.

Método HTTP y URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID:explain

Cuerpo JSON de la solicitud:

{
  "instances": [
    {
      PREDICTION_DATA_ROW
    }
  ],
  "deployedModelId": "DEPLOYED_MODEL_ID"
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID:explain"

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/endpoints/ENDPOINT_ID:explain" | Select-Object -Expand Content

Python

def explain_sample(project: str, location: str, endpoint_id: str, instance_dict: Dict):

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

    endpoint = aiplatform.Endpoint(endpoint_id)

    response = endpoint.explain(instances=[instance_dict], parameters={})

    for explanation in response.explanations:
        print(" explanation")
        # Feature attributions.
        attributions = explanation.attributions
        for attribution in attributions:
            print("  attribution")
            print("   baseline_output_value:", attribution.baseline_output_value)
            print("   instance_output_value:", attribution.instance_output_value)
            print("   output_display_name:", attribution.output_display_name)
            print("   approximation_error:", attribution.approximation_error)
            print("   output_name:", attribution.output_name)
            output_index = attribution.output_index
            for output_index in output_index:
                print("   output_index:", output_index)

    for prediction in response.predictions:
        print(prediction)

Obtener explicaciones de una predicción devuelta anteriormente

Como las explicaciones aumentan el uso de recursos, puede que te interese reservarlas para situaciones en las que las necesites específicamente. A veces, puede ser útil solicitar explicaciones sobre un resultado de inferencia que ya has recibido, quizás porque la inferencia era atípica o no tenía sentido.

Si todas tus inferencias proceden del mismo modelo, puedes volver a enviar los datos de la solicitud y pedir explicaciones esta vez. Sin embargo, si tienes varios modelos que devuelven inferencias, debes asegurarte de enviar la solicitud de explicación al modelo correcto. Para ver las explicaciones de un modelo concreto, incluye el ID del modelo implementado deployedModelID en tu solicitud, que se incluye en la respuesta de la solicitud de inferencia original. Ten en cuenta que el ID del modelo implementado es diferente del ID del modelo.

Interpretar los resultados de la explicación

Para calcular la importancia de las funciones locales, primero se calcula la puntuación de inferencia de referencia. Los valores de referencia se calculan a partir de los datos de entrenamiento. Para ello, se usa la mediana de las características numéricas y la moda de las características categóricas. La inferencia generada a partir de los valores de referencia es la puntuación de inferencia de referencia. Los valores de referencia se calculan una vez para un modelo y no cambian.

En una inferencia específica, la importancia de la función local de cada función te indica cuánto ha sumado o restado esa función al resultado en comparación con la puntuación de inferencia de referencia. La suma de todos los valores de importancia de las características es igual a la diferencia entre la puntuación de inferencia de referencia y el resultado de la inferencia.

En los modelos de clasificación, la puntuación siempre está comprendida entre 0,0 y 1,0 (ambos incluidos). Por lo tanto, los valores de importancia de las funciones locales de los modelos de clasificación siempre están comprendidos entre -1,0 y 1,0 (ambos incluidos).

Para ver ejemplos de consultas de atribución de funciones y obtener más información, consulte Atribuciones de funciones para clasificación y regresión.

Ejemplo de resultado de inferencias y explicaciones

Clasificación

La carga útil de respuesta de una inferencia online de un modelo de clasificación tabular con importancia de las características es similar al siguiente ejemplo.

El instanceOutputValue de 0.928652400970459 es la puntuación de confianza de la clase con la puntuación más alta, en este caso class_a. El campo baselineOutputValue contiene la puntuación de inferencia de referencia 0.808652400970459. La función que más ha contribuido a este resultado es feature_3.

{
"predictions": [
  {
    "scores": [
      0.928652400970459,
      0.071347599029541
    ],
    "classes": [
      "class_a",
      "class_b"
    ]
  }
]
"explanations": [
  {
    "attributions": [
      {
        "baselineOutputValue": 0.808652400970459,
        "instanceOutputValue": 0.928652400970459,
        "approximationError":  0.0058915703929231,
        "featureAttributions": {
          "feature_1": 0.012394922231235,
          "feature_2": 0.050212341234556,
          "feature_3": 0.057392736534209,
        },
        "outputIndex": [
          0
        ],
        "outputName": "scores"
      }
    ],
  }
]
"deployedModelId": "234567"
}

Regresión

La carga útil de respuesta de una inferencia online con la importancia de las características de un modelo de regresión tabular es similar al siguiente ejemplo.

El instanceOutputValue de 1795.1246466281819 es el valor previsto, y los campos lower_bound y upper_bound proporcionan el intervalo de confianza del 95 %. El campo baselineOutputValue contiene la puntuación de inferencia de referencia 1788.7423095703125. La función que más ha contribuido a este resultado es feature_3.

{
"predictions": [
  {
    "value": 1795.1246466281819,
    "lower_bound": 246.32196807861328,
    "upper_bound": 8677.51904296875
  }
]
"explanations": [
  {
    "attributions": [
      {
        "baselineOutputValue": 1788.7423095703125,
        "instanceOutputValue": 1795.1246466281819,
        "approximationError": 0.0038215703911553,
        "featureAttributions": {
          "feature_1": 0.123949222312359,
          "feature_2": 0.802123412345569,
          "feature_3": 5.456264423211472,
        },
        "outputIndex": [
          -1
        ]
      }
    ]
  }
],
"deployedModelId": "345678"
}

Siguientes pasos

Consulta cómo exportar tu modelo.

Obtener inferencias y explicaciones online Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Desplegar un modelo en un endpoint

Google Cloud consola

API

Crear un punto final

gcloud

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Java

Node.js

Python

Obtener el ID del endpoint

gcloud

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Desplegar el modelo

gcloud

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

Dividir el tráfico

Linux, macOS o Cloud Shell

Windows (PowerShell)

Windows (cmd.exe)

REST

curl (Linux, macOS o Cloud Shell)

PowerShell (Windows)

Java

Python

Node.js

Obtener el estado de la operación

Obtener una inferencia online con el modelo desplegado

Google Cloud consola

API: Classification

gcloud

REST

curl

PowerShell

Java

Node.js

Python

API: regresión

gcloud

REST

curl

PowerShell

Java

Node.js

Python

Interpretar los resultados de las predicciones

Clasificación

Regresión

Obtener una explicación online con tu modelo desplegado

Consola

gcloud

REST

curl

PowerShell

Python

Interpretar los resultados de la explicación

Ejemplo de resultado de inferencias y explicaciones

Clasificación

Regresión

Siguientes pasos

Obtener inferencias y explicaciones online