Obtén predicciones por lotes de amplitud & profundidad

En esta página, se muestra cómo enviar una solicitud de predicción por lotes a tu modelo de regresión o clasificación entrenado con la consola de Google Cloud o la API de Vertex AI.

Una solicitud de predicción por lotes es una solicitud asíncrona (a diferencia de la predicción en línea, que es una solicitud síncrona). Las predicciones por lotes se solicitan directamente desde el recurso de modelo sin necesidad de implementar el modelo en un extremo. Para los datos tabulares, usa predicciones por lotes cuando no necesites una respuesta inmediata y desees procesar datos acumulados mediante una sola solicitud.

Para realizar una predicción por lotes, especifica una fuente de entrada y un formato de salida en el que Vertex AI almacene los resultados de las predicciones.

Antes de comenzar

Antes de que puedas realizar una solicitud de predicción por lotes, primero debes entrenar un modelo.

Datos de entrada

Los datos de entrada para las solicitudes de predicción por lotes son los que usa tu modelo a fin de hacer predicciones. Para los modelos de regresión o clasificación, puedes proporcionar datos de entrada en uno de estos dos formatos:

  • Tablas de BigQuery
  • Objetos CSV en Cloud Storage

Te recomendamos que uses para los datos de entrada el mismo formato que usaste para entrenar el modelo. Por ejemplo, si entrenaste tu modelo con datos en BigQuery, es mejor usar una tabla de BigQuery como la entrada de tus predicción por lotes. Debido a que Vertex AI trata todos los campos de entrada CSV como cadenas, la mezcla de los formatos de datos de entrada y entrenamiento puede generar errores.

La fuente de datos debe contener datos tabulares que incluyan todas las columnas, en cualquier orden, que se usaron para entrenar el modelo. Puedes incluir columnas que no estaban en los datos de entrenamiento o que estaban en los datos de entrenamiento, pero que no se usaron para el entrenamiento. Estas columnas adicionales se incluyen en el resultado, pero no afectan los resultados de la predicción.

Requisitos de los datos de entrada

Tabla de BigQuery

Si eliges una tabla de BigQuery como entrada, debes asegurarte de lo siguiente:

  • Las tablas de fuentes de datos de BigQuery no deben superar los 100 GB.
  • Si la tabla está en un proyecto diferente, debes proporcionar el rol BigQuery Data Editor a la cuenta de servicio de Vertex AI en ese proyecto.

Archivo CSV

Si eliges un objeto CSV en Cloud Storage como entrada, debes asegurarte de lo siguiente:

  • La fuente de datos debe comenzar con una fila de encabezado con los nombres de las columnas.
  • Cada objeto de fuente de datos no debe superar los 10 GB. Puedes incluir varios archivos, hasta un máximo de 100 GB.
  • Si el bucket de Cloud Storage está en un proyecto diferente, debes otorgar el rol Storage Object Creator a la cuenta de servicio de Vertex AI en ese proyecto.
  • Debes encerrar todas las strings entre comillas dobles (”).

Formato de salida

No es necesario que el formato de salida de tu solicitud de predicción por lotes sea el mismo que usaste para la entrada. Por ejemplo, si usaste la tabla de BigQuery como entrada, puedes generar los resultados en un objeto CSV en Cloud Storage.

Realiza una solicitud de predicción por lotes a tu modelo

Para realizar solicitudes de predicción por lotes, puedes usar la consola de Google Cloud o la API de Vertex AI. La fuente de datos de entrada pueden ser objetos CSV almacenados en un bucket de Cloud Storage o tablas de BigQuery. Según la cantidad de datos que envíes como entrada, una tarea de predicción por lotes puede tomar cierto tiempo en completarse.

Consola de Google Cloud

Usa la consola de Google Cloud para solicitar una predicción por lotes.

  1. En la consola de Google Cloud, en la sección Vertex AI, ve a la página Predicciones Batch.

    Ir a la página Batch predictions

  2. Haz clic en Crear para abrir la ventana Nueva predicción por lotes.
  3. Para Definir la predicción por lotes, sigue estos pasos:
    1. Ingresa un nombre para la predicción por lotes.
    2. En Nombre del modelo, selecciona el nombre del modelo que usarás para esta predicción por lotes.
    3. En Versión, selecciona la versión del modelo que se usará para esta predicción por lotes.
    4. En Seleccionar fuente, selecciona si tus datos de entrada de origen son un archivo CSV en Cloud Storage o una tabla en BigQuery.
      • Para los archivos CSV, especifica la ubicación de Cloud Storage en la que se encuentra el archivo de entrada CSV.
      • Para las tablas de BigQuery, especifica el ID del proyecto en el que se encuentra la tabla, el ID del conjunto de datos de BigQuery y el ID de vista o la tabla de BigQuery.
    5. En el Resultado, selecciona CSV o BigQuery.
      • Para CSV, especifica el bucket de Cloud Storage en el que Vertex AI almacenará tu resultado.
      • Para BigQuery, puedes especificar un ID del proyecto o un conjunto de datos existente:
        • Para especificar el ID del proyecto, ingresa el ID en el campo ID del proyecto de Google Cloud. Vertex AI crea un nuevo conjunto de datos de salida.
        • Para especificar un conjunto de datos existente, ingresa su ruta de BigQuery en el campo ID del proyecto de Google Cloud, como bq://projectid.datasetid.
  4. Opcional: El análisis de Supervisión de modelos para predicciones por lotes está disponible en vista previa. Consulta los Requisitos previos para agregar configuración de detección de sesgo a tu trabajo de predicción por lotes.
    1. Haz clic para activar o desactivar Habilitar la supervisión del modelo para esta predicción por lotes.
    2. Selecciona una fuente de datos de entrenamiento. Ingresa la ruta de acceso o la ubicación de los datos para la fuente de datos de entrenamiento que seleccionaste.
    3. Opcional: En Umbrales de alerta, especifica los umbrales para activar las alertas.
    4. En Notificaciones por correo electrónico, ingresa una o más direcciones de correo electrónico separadas por comas para recibir alertas cuando un modelo supere un umbral de alertas.
    5. En los Canales de notificaciones, agrega canales de Cloud Monitoring para recibir alertas cuando un modelo exceda un umbral de alertas (opcional). Puedes seleccionar canales existentes de Cloud Monitoring o crear uno nuevo haciendo clic en Administrar canales de notificaciones. La consola es compatible con los canales de notificaciones de PagerDuty, Slack y Pub/Sub.
  5. Haz clic en Crear.

API: BigQuery

REST

Usa el método batchPredictionJobs.create para solicitar una predicción por lotes.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION_ID: Región en la que se almacena el modelo y se ejecuta el trabajo de predicción por lotes. Por ejemplo: us-central1.
  • PROJECT_ID: el ID de tu proyecto
  • BATCH_JOB_NAME: el nombre visible del trabajo por lotes
  • MODEL_ID: El ID del modelo que se usará para hacer predicciones
  • INPUT_URI: referencia a la fuente de datos de BigQuery. En el formulario, haz lo siguiente: 
    bq://bqprojectId.bqDatasetId.bqTableId
  • OUTPUT_URI: Referencia al destino de BigQuery (en el que se escribirán las predicciones). Especifica el ID del proyecto y, de forma opcional, un ID de conjunto de datos existente. Si especificas solo el ID del proyecto, Vertex AI crea un nuevo conjunto de datos de salida. Usa el siguiente formulario: 
    bq://bqprojectId.bqDatasetId
  • MACHINE_TYPE: los recursos de máquina que se usarán para este trabajo de predicción por lotes. Obtenga más información.
  • STARTING_REPLICA_COUNT: la cantidad inicial de nodos para este trabajo de predicción por lotes. El recuento de nodos se puede aumentar o disminuir según sea necesario por la carga, hasta la cantidad máxima de nodos, pero nunca será inferior a este número.
  • MAX_REPLICA_COUNT: la cantidad máxima de nodos para este trabajo de predicción por lotes. El recuento de nodos se puede aumentar o disminuir según sea necesario por la carga, pero nunca excederá el máximo. Opcional, el valor predeterminado es 10.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud:

{
  "displayName": "BATCH_JOB_NAME",
  "model": "MODEL_ID",
  "inputConfig": {
    "instancesFormat": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
      "outputUri": "OUTPUT_URI"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT,
    "maxReplicaCount": MAX_REPLICA_COUNT
  },

}

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/batchPredictionJobs"

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/batchPredictionJobs" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs/67890",
  "displayName": "batch_job_1 202005291958",
  "model": "projects/12345/locations/us-central1/models/5678",
  "state": "JOB_STATE_PENDING",
  "inputConfig": {
    "instancesFormat": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
        "outputUri": bq://12345
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-32",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 2,
    "maxReplicaCount": 6
  },
  "manualBatchTuningParameters": {
    "batchSize": 4
  },
  "generateExplanation": false,
  "outputInfo": {
    "bigqueryOutputDataset": "bq://12345.reg_model_2020_10_02_06_04
  }
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-30T02:58:44.341643Z",
  "updateTime": "2020-09-30T02:58:44.341643Z",
}

Java

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

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

En el siguiente ejemplo, reemplaza INSTANCES_FORMAT y PREDICTIONS_FORMAT por “bigquery”. Para obtener información para reemplazar los otros marcadores de posición, consulta la pestaña “LÍNEA DE REST Y CMD” de esta sección. 
import com.google.cloud.aiplatform.v1.BatchPredictionJob;
import com.google.cloud.aiplatform.v1.BigQueryDestination;
import com.google.cloud.aiplatform.v1.BigQuerySource;
import com.google.cloud.aiplatform.v1.JobServiceClient;
import com.google.cloud.aiplatform.v1.JobServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.gson.JsonObject;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class CreateBatchPredictionJobBigquerySample {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String displayName = "DISPLAY_NAME";
    String modelName = "MODEL_NAME";
    String instancesFormat = "INSTANCES_FORMAT";
    String bigquerySourceInputUri = "BIGQUERY_SOURCE_INPUT_URI";
    String predictionsFormat = "PREDICTIONS_FORMAT";
    String bigqueryDestinationOutputUri = "BIGQUERY_DESTINATION_OUTPUT_URI";
    createBatchPredictionJobBigquerySample(
        project,
        displayName,
        modelName,
        instancesFormat,
        bigquerySourceInputUri,
        predictionsFormat,
        bigqueryDestinationOutputUri);
  }

  static void createBatchPredictionJobBigquerySample(
      String project,
      String displayName,
      String model,
      String instancesFormat,
      String bigquerySourceInputUri,
      String predictionsFormat,
      String bigqueryDestinationOutputUri)
      throws IOException {
    JobServiceSettings settings =
        JobServiceSettings.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 (JobServiceClient client = JobServiceClient.create(settings)) {
      JsonObject jsonModelParameters = new JsonObject();
      Value.Builder modelParametersBuilder = Value.newBuilder();
      JsonFormat.parser().merge(jsonModelParameters.toString(), modelParametersBuilder);
      Value modelParameters = modelParametersBuilder.build();
      BigQuerySource bigquerySource =
          BigQuerySource.newBuilder().setInputUri(bigquerySourceInputUri).build();
      BatchPredictionJob.InputConfig inputConfig =
          BatchPredictionJob.InputConfig.newBuilder()
              .setInstancesFormat(instancesFormat)
              .setBigquerySource(bigquerySource)
              .build();
      BigQueryDestination bigqueryDestination =
          BigQueryDestination.newBuilder().setOutputUri(bigqueryDestinationOutputUri).build();
      BatchPredictionJob.OutputConfig outputConfig =
          BatchPredictionJob.OutputConfig.newBuilder()
              .setPredictionsFormat(predictionsFormat)
              .setBigqueryDestination(bigqueryDestination)
              .build();
      String modelName = ModelName.of(project, location, model).toString();
      BatchPredictionJob batchPredictionJob =
          BatchPredictionJob.newBuilder()
              .setDisplayName(displayName)
              .setModel(modelName)
              .setModelParameters(modelParameters)
              .setInputConfig(inputConfig)
              .setOutputConfig(outputConfig)
              .build();
      LocationName parent = LocationName.of(project, location);
      BatchPredictionJob response = client.createBatchPredictionJob(parent, batchPredictionJob);
      System.out.format("response: %s\n", response);
      System.out.format("\tName: %s\n", response.getName());
    }
  }
}

Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de Python.

En el ejemplo siguiente, configura los parámetros “instances_format” y “predictions_format” como “bigquery”. Para aprender a establecer los otros parámetros, consulta la pestaña “REST y CMD LINE” de esta sección. 
from google.cloud import aiplatform_v1beta1
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value


def create_batch_prediction_job_bigquery_sample(
    project: str,
    display_name: str,
    model_name: str,
    instances_format: str,
    bigquery_source_input_uri: str,
    predictions_format: str,
    bigquery_destination_output_uri: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform_v1beta1.JobServiceClient(client_options=client_options)
    model_parameters_dict = {}
    model_parameters = json_format.ParseDict(model_parameters_dict, Value())

    batch_prediction_job = {
        "display_name": display_name,
        # Format: 'projects/{project}/locations/{location}/models/{model_id}'
        "model": model_name,
        "model_parameters": model_parameters,
        "input_config": {
            "instances_format": instances_format,
            "bigquery_source": {"input_uri": bigquery_source_input_uri},
        },
        "output_config": {
            "predictions_format": predictions_format,
            "bigquery_destination": {"output_uri": bigquery_destination_output_uri},
        },
        # optional
        "generate_explanation": True,
    }
    parent = f"projects/{project}/locations/{location}"
    response = client.create_batch_prediction_job(
        parent=parent, batch_prediction_job=batch_prediction_job
    )
    print("response:", response)

API: Cloud Storage

REST

Usa el método batchPredictionJobs.create para solicitar una predicción por lotes.

Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:

  • LOCATION_ID: Región en la que se almacena el modelo y se ejecuta el trabajo de predicción por lotes. Por ejemplo: us-central1.
  • PROJECT_ID: el ID de tu proyecto
  • BATCH_JOB_NAME: el nombre visible del trabajo por lotes
  • MODEL_ID: El ID del modelo que se usará para hacer predicciones
  • URI: rutas de acceso (URI) a los buckets de Cloud Storage que contienen los datos de entrenamiento. Puede haber más de una. Cada URI tiene el siguiente formulario:
    gs://bucketName/pathToFileName
  • OUTPUT_URI_PREFIX: Ruta a un destino de Cloud Storage en el que se escribirán las predicciones. Vertex AI escribe predicciones por lotes en un subdirectorio con marca de tiempo de esta ruta de acceso. Establece este valor en una cadena con el siguiente formato: 
    gs://bucketName/pathToOutputDirectory
  • MACHINE_TYPE: los recursos de máquina que se usarán para este trabajo de predicción por lotes. Obtenga más información.
  • STARTING_REPLICA_COUNT: la cantidad inicial de nodos para este trabajo de predicción por lotes. El recuento de nodos se puede aumentar o disminuir según sea necesario por la carga, hasta la cantidad máxima de nodos, pero nunca será inferior a este número.
  • MAX_REPLICA_COUNT: la cantidad máxima de nodos para este trabajo de predicción por lotes. El recuento de nodos se puede aumentar o disminuir según sea necesario por la carga, pero nunca excederá el máximo. Opcional, el valor predeterminado es 10.

Método HTTP y URL: 

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

Cuerpo JSON de la solicitud:

{
  "displayName": "BATCH_JOB_NAME",
  "model": "MODEL_ID",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": [
        URI1,...
      ]
    },
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "MACHINE_TYPE",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": STARTING_REPLICA_COUNT,
    "maxReplicaCount": MAX_REPLICA_COUNT
  },

}

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/batchPredictionJobs"

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/batchPredictionJobs" | Select-Object -Expand Content

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/PROJECT__ID/locations/LOCATION_ID/batchPredictionJobs/67890",
  "displayName": "batch_job_1 202005291958",
  "model": "projects/12345/locations/us-central1/models/5678",
  "state": "JOB_STATE_PENDING",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": [
        "gs://bp_bucket/reg_mode_test"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "dedicatedResources": {
    "machineSpec": {
      "machineType": "n1-standard-32",
      "acceleratorCount": "0"
    },
    "startingReplicaCount": 2,
    "maxReplicaCount": 6
  },
  "manualBatchTuningParameters": {
    "batchSize": 4
  }
  "outputInfo": {
    "gcsOutputDataset": "OUTPUT_URI_PREFIX/prediction-batch_job_1 202005291958-2020-09-30T02:58:44.341643Z"
  }
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-09-30T02:58:44.341643Z",
  "updateTime": "2020-09-30T02:58:44.341643Z",
}

Recupera los resultados de las predicciones por lotes

Vertex AI envía el resultado de las predicciones por lotes al destino que especificaste, que puede ser BigQuery o Cloud Storage.

BigQuery

Conjunto de datos de salida

Si usas BigQuery, el resultado de la predicción por lotes se almacena en un conjunto de datos de salida. Si proporcionaste un conjunto de datos a Vertex AI, el nombre del conjunto de datos (BQ_DATASET_NAME) es el nombre que proporcionaste antes. Si no proporcionaste un conjunto de datos de salida, Vertex AI creó uno para ti. Puedes encontrar su nombre (BQ_DATASET_NAME) a través de los siguientes pasos:

  1. En la consola de Google Cloud, ve a la página Predicciones Batch de Vertex AI.

    Ir a la página Batch predictions

  2. Selecciona la predicción que creaste.
  3. El conjunto de datos de salida se proporciona en Exportar ubicación. El nombre del conjunto de datos tiene el siguiente formato: prediction_MODEL_NAME_TIMESTAMP
Tablas de salida

El conjunto de datos de salida contiene una o más de las siguientes tres tablas de salida:

  • Tabla de predicciones

    Esta tabla contiene una fila por cada fila de tus datos de entrada en la que se solicitó una predicción (es decir, en las que TARGET_COLUMN_NAME = nulo).

  • Tabla de errores

    Esta tabla contiene una fila para cada error no crítico encontrado durante la predicción por lotes. Cada error no crítico corresponde a una fila en los datos de entrada para la que Vertex AI no pudo devolver una previsión.

Tabla de predicciones

El nombre de la tabla (BQ_PREDICTIONS_TABLE_NAME) se forma mediante la unión de “predictions_” con la marca de tiempo de cuándo se inició el trabajo de predicción por lotes: predictions_TIMESTAMP

Para recuperar predicciones, ve a la página de BigQuery.

Ir a BigQuery

El formato de la consulta depende del tipo de modelo:

Clasificación:

SELECT predicted_TARGET_COLUMN_NAME.classes AS classes,
predicted_TARGET_COLUMN_NAME.scores AS scores
FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

classes es la lista de clases potenciales, y scores son las las puntuaciones de confianza correspondientes.

Regresión:

SELECT predicted_TARGET_COLUMN_NAME.value
FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

Si tu modelo usa inferencia probabilística, predicted_TARGET_COLUMN_NAME.value contiene el minimizador del objetivo de optimización. Por ejemplo, si tu objetivo de optimización es minimize-rmse, predicted_TARGET_COLUMN_NAME.value contiene el valor medio. Si es minimize-mae, el campo predicted_TARGET_COLUMN_NAME.value contiene el valor de la mediana.

Si tu modelo usa inferencias probabilísticas con cuantiles, Vertex AI proporciona valores y predicciones cuantiles, además del minimizador del objetivo de optimización. Los valores cuantiles se establecen durante el entrenamiento de modelos. Las predicciones de cuantiles son los valores de predicción asociados con los valores cuantiles.

Tabla de errores

El nombre de la tabla (BQ_ERRORS_TABLE_NAME) se forma mediante la unión de errors_ con la marca de tiempo de inicio del trabajo de predicción por lotes:errors_TIMESTAMPpara recuperar la tabla de validación de errores:

  1. En la consola, ve a la página BigQuery.

    Ir a BigQuery

  2. Ejecuta la siguiente consulta: 
    SELECT * FROM BQ_DATASET_NAME.BQ_ERRORS_TABLE_NAME
Los errores se almacenan en las siguientes columnas:
  • errors_TARGET_COLUMN_NAME.code
  • errors_TARGET_COLUMN_NAME.message

Cloud Storage

Si especificaste Cloud Storage como tu destino de salida, los resultados de su solicitud de predicción por lotes se mostrarán como objetos CSV en una nueva carpeta del bucket que especificaste. El nombre de la carpeta es el nombre de tu modelo, precedido de “prediction_” y con la marca de tiempo de inicio del trabajo de predicción del lote al final. Puedes encontrar el nombre de la carpeta de Cloud Storage en la pestaña Predicciones Batch de tu modelo.

La carpeta de Cloud Storage contiene dos tipos de objetos:
  • Objetos de predicción

    Los objetos de predicción se denominan “predictions_1.csv”, “predictions_2.csv” y así sucesivamente. Contienen una fila de encabezado con los nombres de las columnas y una fila para cada predicción que se muestra. En los objetos de predicción, Vertex AI muestra los datos de predicción y crea una o más columnas nuevas para los resultados de la predicción, según el tipo de modelo:

    • Clasificación: Para cada valor potencial de tu columna de destino, se agrega una columna llamada TARGET_COLUMN_NAME_VALUE_score a los resultados. Esta columna contiene la puntuación o estimación de confianza de ese valor.
    • Regresión: El valor previsto para esa fila se muestra en una columna llamada predicted_TARGET_COLUMN_NAME. No se muestra el intervalo de predicción para la salida de CSV.
  • Objetos de error

    Los objetos de error se denominan “errors_1.csv”, “errors_2.csv”, y así sucesivamente. Contienen una fila de encabezado y una fila para cada fila en tus datos de entrada para la que Vertex AI no pudo mostrar una predicción (por ejemplo, si un atributo que no admite valores nulos fue nulo).

Nota: Si los resultados son grandes, se dividen en varios objetos.

Interpreta los resultados de la predicción

Clasificación

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

La puntuación de confianza comunica cuán fuerte tu modelo asocia cada clase o etiqueta con un elemento de prueba. Cuanto más alto sea el número, mayor será la confianza del modelo de que la etiqueta se debe aplicar a ese elemento. Tú decides qué tan alta debe ser la puntuación de confianza para que aceptes los resultados del modelo.

Regresión

Los modelos de regresión muestran un valor de predicción.

Si tu modelo usa inferencia probabilística, el campo value contiene el minimizador del objetivo de optimización. Por ejemplo, si tu objetivo de optimización es minimize-rmse, el campo value contiene el valor medio. Si es minimize-mae, el campo value contiene el valor de la media.

Si tu modelo usa inferencias probabilísticas con cuantiles, Vertex AI proporciona valores y predicciones cuantiles, además del minimizador del objetivo de optimización. Los valores cuantiles se establecen durante el entrenamiento de modelos. Las predicciones de cuantiles son los valores de predicción asociados con los valores cuantiles.

¿Qué sigue?