Obtén predicciones para un modelo de previsión

En esta página, se muestra cómo crear una previsión con tu modelo de previsión entrenado.

Para crear una previsión, realiza una solicitud de predicción por lotes directamente a tu modelo de previsión y especifica una fuente de entrada y una ubicación de salida a fin de almacenar los resultados de la previsión.

La previsión con AutoML no es compatible con la implementación de extremos ni las predicciones en línea. Si deseas solicitar predicciones en línea desde tu modelo de previsión, usa el flujo de trabajo tabular para la previsión.

Puedes solicitar una predicción con explicaciones (también llamadas atribuciones de atributos) para ver cómo el modelo llegó a una predicción. Los valores de importancia de los atributos locales indican cuánto contribuyó cada atributo al resultado de la predicción. A fin de obtener una descripción general conceptual, consulta Atribuciones de atributos para la previsión.

Antes de comenzar

Antes de crear una previsión, debes entrenar un modelo de previsión.

Datos de entrada

Los datos de entrada para las solicitudes de predicción por lotes son los que usa tu modelo para crear previsiones. Puedes proporcionar datos de entrada en uno de estos dos formatos:

  • Objetos CSV en Cloud Storage
  • Tablas de BigQuery

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 previsión.

Requisitos de los datos de entrada

La entrada para los modelos de previsión debe cumplir con los siguientes requisitos:

  • Todos los valores de la columna de tiempo deben estar presentes y ser válidos.
  • La frecuencia de los datos de entrada y los datos de entrenamiento deben coincidir. Si faltan filas en la serie temporal, debes insertarlas manualmente según el conocimiento de dominio adecuado.
  • Las series temporales con marcas de tiempo duplicadas se quitan de las predicciones. Para incluirlas, quita las marcas de tiempo duplicadas.
  • Proporciona datos históricos de cada serie temporal que se preverá. Para obtener las previsiones más precisas, la cantidad de datos debe ser igual al período de contexto, que se establece durante el entrenamiento del modelo. Por ejemplo, si la ventana de contexto es de 14 días, proporciona al menos 14 días de datos históricos. Si proporcionas menos datos, Vertex AI rellena los datos con valores vacíos.
  • La previsión comienza en la primera fila de una serie temporal (ordenada por tiempo) con un valor nulo en la columna de destino. El valor nulo debe ser continuo dentro de la serie temporal. Por ejemplo, si la columna de destino está ordenada por tiempo, no puedes tener algo como 1, 2, null, 3, 4, null, null para una sola serie temporal. En el caso de los archivos CSV, Vertex AI considera una cadena vacía como nula y, para BigQuery, los valores nulos son compatibles de forma nativa.

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 cadenas 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 de la previsión 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.
    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 Resultado de la predicción Batch, 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.
      • Opcional. Si tu destino de salida es BigQuery o JSONL en Cloud Storage, puedes habilitar las atribuciones de atributos además de las predicciones. Para ello, selecciona Habilitar atribuciones de atributos para este modelo. Las atribuciones de atributos no son compatibles con CSV en Cloud Storage. Obtén más información.
  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. Usa el siguiente formato: 
    bq://bqprojectId.bqDatasetId
     Si especificas solo el ID del proyecto, Vertex AI crea un nuevo conjunto de datos de salida. Usa el siguiente formato: 
    bq://bqprojectId
  • GENERATE_EXPLANATION: El valor predeterminado es falso. Configúralo en true para habilitar las atribuciones de atributos. Si deseas obtener más información, consulta Atribuciones de atributos para la previsión.

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": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "bigquery",
    "bigquerySource": {
      "inputUri": "INPUT_URI"
    }
  },
  "outputConfig": {
    "predictionsFormat": "bigquery",
    "bigqueryDestination": {
      "outputUri": "OUTPUT_URI"
    }
  },
  "generate_explanation": GENERATE_EXPLANATION
}

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
  },
  "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. 

def create_batch_prediction_job_bigquery_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    bigquery_source: str,
    bigquery_destination_prefix: str,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        bigquery_source=bigquery_source,
        bigquery_destination_prefix=bigquery_destination_prefix,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

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 uno. Cada URI tiene el siguiente formato: 
    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
  • GENERATE_EXPLANATION: El valor predeterminado es falso. Configúralo en true para habilitar las atribuciones de atributos. Esta opción solo está disponible si tu destino de salida es JSONL. Las atribuciones de atributos no son compatibles con CSV en Cloud Storage. Si deseas obtener más información, consulta Atribuciones de atributos para la previsión.

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": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "csv",
    "gcsSource": {
      "uris": [
        URI1,...
      ]
    },
  },
  "outputConfig": {
    "predictionsFormat": "csv",
    "gcsDestination": {
      "outputUriPrefix": "OUTPUT_URI_PREFIX"
    }
  },
  "generate_explanation": GENERATE_EXPLANATION
}

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
  }
  "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",
}

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. 

def create_batch_prediction_job_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

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.

Actualmente, no se admite el resultado de Cloud Storage para las atribuciones de atributos.

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 por lotes 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). Por ejemplo, si tu entrada incluyó 14 entradas nulas para la columna objetivo (como las ventas de los próximos 14 días), tu solicitud de predicción devuelve 14 filas, la cantidad de ventas de cada día. Si tu solicitud de predicción excede el horizonte de previsión del modelo, Vertex AI solo devuelve las predicciones hasta el horizonte de previsión.

  • Tabla de validación de errores

    Esta tabla contiene una fila para cada error no crítico encontrado durante la fase de agregación que se produce antes de 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 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 a través de 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 la tabla de predicciones, sigue estos pasos:

  1. En la consola, ve a la página BigQuery.
    Ir a BigQuery
  2. Ejecuta la siguiente búsqueda: 
    SELECT * FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

Vertex AI almacena las predicciones en la columna predicted_TARGET_COLUMN_NAME.value.

Si entrenaste un modelo con Temporal Fusion Transformer (TFT), puedes encontrar el resultado de interpretabilidad de TFT en la columna predicted_TARGET_COLUMN_NAME.tft_feature_importance:

Esta columna está dividida en lo siguiente:

  • context_columns: Atributos de previsión cuyos valores de ventana de contexto sirven como entradas para el codificador de memoria a corto plazo (LSTM) de TFT.
  • context_weights: Los pesos de importancia de las funciones asociadas con cada uno de los context_columns para la instancia prevista.
  • horizon_columns: Atributos de previsión cuyos valores de horizonte de previsión sirven como entradas para el codificador de memoria a corto plazo (LSTM) de TFT.
  • horizon_weights: Los pesos de importancia de las funciones asociadas con cada uno de los horizon_columns para la instancia prevista.
  • attribute_columns: Funciones de previsión que son invariables de tiempo.
  • attribute_weights: Son las ponderaciones asociadas con cada una de las attribute_columns.

Si tu modelo está optimizado para la pérdida de cuantiles y tu conjunto de cuantiles incluye la mediana, predicted_TARGET_COLUMN_NAME.value es el valor de la predicción en el promedio. De lo contrario, predicted_TARGET_COLUMN_NAME.value es el valor de predicción en el cuantil más bajo del conjunto. Por ejemplo, si tu conjunto de cuantiles es [0.1, 0.5, 0.9], value es la predicción del cuantil 0.5. Si tu conjunto de cuantiles es [0.1, 0.9], value es la predicción del cuantil 0.1.

Además, Vertex AI almacena valores y predicciones de cuantiles en las siguientes columnas:

  • predicted_TARGET_COLUMN_NAME.quantile_values: Los valores de los cuantiles, que se establecen durante el entrenamiento del modelo. Por ejemplo, pueden ser 0.1, 0.5 y 0.9.
  • predicted_TARGET_COLUMN_NAME.quantile_predictions: Los valores de predicción asociados con los valores cuantiles.

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, predicted_TARGET_COLUMN_NAME.value contiene el valor de la mediana.

Si tu modelo usa inferencia probabilística con cuantiles, Vertex AI almacena los valores y predicciones de los cuantiles en las siguientes columnas:

  • predicted_TARGET_COLUMN_NAME.quantile_values: Los valores de los cuantiles, que se establecen durante el entrenamiento del modelo. Por ejemplo, pueden ser 0.1, 0.5 y 0.9.
  • predicted_TARGET_COLUMN_NAME.quantile_predictions: Los valores de predicción asociados con los valores cuantiles.

Si habilitaste las atribuciones de atributos, también puedes encontrarlas en la tabla de predicciones. Para acceder a las atribuciones de un atributo BQ_FEATURE_NAME, ejecuta la siguiente búsqueda:

SELECT explanation.attributions[OFFSET(0)].featureAttributions.BQ_FEATURE_NAME FROM BQ_DATASET_NAME.BQ_PREDICTIONS_TABLE_NAME

Si deseas obtener más información, consulta Atribuciones de atributos para la previsión.

Tabla de validación de errores

El nombre de la tabla (BQ_ERRORS_VALIDATION_TABLE_NAME) se forma a través de la unión de “errors_validation” con la marca de tiempo de cuándo se inició el trabajo de predicción por lotes: errors_validation_TIMESTAMP

Para recuperar la tabla de validación de errores, haz lo siguiente:
  1. En la consola, ve a la página BigQuery.
    Ir a BigQuery
  2. Ejecuta la siguiente búsqueda: 
    SELECT * FROM BQ_DATASET_NAME.BQ_ERRORS_VALIDATION_TABLE_NAME
El mensaje de error se almacena en la siguiente columna:
  • errors_TARGET_COLUMN_NAME

Tabla de errores

El nombre de la tabla (BQ_ERRORS_TABLE_NAME) se forma a través de la unión de “errors_” con la marca de tiempo de cuándo se inició el trabajo de predicción por lotes: errors_TIMESTAMP

Para recuperar la tabla de validación de errores, haz lo siguiente:
  1. En la consola, ve a la página BigQuery.
    Ir a BigQuery
  2. Ejecuta la siguiente búsqueda: 
    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 devolverá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 previsión que se devuelve. La cantidad de valores de predicción depende del horizonte de predicción y de entrada de la previsión. Por ejemplo, si tu entrada incluyó 14 entradas nulas para la columna objetivo (como las ventas de los próximos 14 días), tu solicitud de predicción devuelve 14 filas, la cantidad de ventas de cada día. Si tu solicitud de predicción excede el horizonte de previsión del modelo, Vertex AI solo devuelve las predicciones hasta el horizonte de previsión.

    Los valores previstos se devuelven en una columna llamada “predicted_TARGET_COLUMN_NAME”. Para las previsiones de cuantiles, la columna de salida contiene las predicciones y los valores de cuantiles en formato JSON.

  • 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 devolver una previsión (por ejemplo, si un atributo que no admite valores nulos es nulo).

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

Consultas de atribución de atributos de muestra en BigQuery

Ejemplo 1: Determina las atribuciones para una sola predicción

Ten en cuenta la siguiente pregunta:

¿En qué medida un anuncio de un producto aumentó las ventas previstas el 24 de noviembre en una tienda determinada?

La búsqueda correspondiente es la siguiente:

SELECT
  * EXCEPT(explanation, predicted_sales),
  ROUND(predicted_sales.value, 2) AS predicted_sales,
  ROUND(
    explanation.attributions[OFFSET(0)].featureAttributions.advertisement,
    2
  ) AS attribution_advertisement
FROM
  `project.dataset.predictions`
WHERE
  product = 'product_0'
  AND store = 'store_0'
  AND date = '2019-11-24'

Ejemplo 2: Determina la importancia de los atributos globales

Ten en cuenta la siguiente pregunta:

¿Cuánto contribuyó cada atributo a las ventas previstas en general?

Para calcular de forma manual la importancia de los atributos globales, agrega las atribuciones locales de importancia de los atributos. La búsqueda correspondiente es la siguiente:

WITH

/*
* Aggregate from (id, date) level attributions to global feature importance.
*/
attributions_aggregated AS (
 SELECT
   SUM(ABS(attributions.featureAttributions.date)) AS date,
   SUM(ABS(attributions.featureAttributions.advertisement)) AS advertisement,
   SUM(ABS(attributions.featureAttributions.holiday)) AS holiday,
   SUM(ABS(attributions.featureAttributions.sales)) AS sales,
   SUM(ABS(attributions.featureAttributions.store)) AS store,
   SUM(ABS(attributions.featureAttributions.product)) AS product,
 FROM
   project.dataset.predictions,
   UNNEST(explanation.attributions) AS attributions

),

/*
* Calculate the normalization constant for global feature importance.
*/
attributions_aggregated_with_total AS (
 SELECT
   *,
   date + advertisement + holiday + sales + store + product AS total
 FROM
   attributions_aggregated
)

/*
* Calculate the normalized global feature importance.
*/
SELECT
 ROUND(date / total, 2) AS date,
 ROUND(advertisement / total, 2) AS advertisement,
 ROUND(holiday / total, 2) AS holiday,
 ROUND(sales / total, 2) AS sales,
 ROUND(store / total, 2) AS store,
 ROUND(product / total, 2) AS product,
FROM
 attributions_aggregated_with_total

Ejemplo de resultado de la predicción por lotes en BigQuery

En un conjunto de datos de ejemplo de ventas de licores, hay cuatro tiendas en la ciudad de "Ida Grove": "Ida Grove Food Pride", "Discount Liquors of Ida Grove", "Tienda general de Casey #3757", y "Brew Ida Grove". store_name es el series identifier y tres de los cuatro almacenes solicitan predicciones para la columna de destino sale_dollars. Se genera un error de validación porque no se solicitó ninguna previsión de “Discount Liquors of Ida Grove”.

El siguiente es un extracto del conjunto de datos de entrada que se usa para la predicción:

Conjunto de datos de entrada de muestra para la predicción de previsión

El siguiente es un extracto de los resultados de la predicción:

Resultados de la previsión de muestra

El siguiente es un extracto de los errores de validación:

Ejemplos de errores de validación

Ejemplo de resultado de la predicción por lotes de un modelo optimizado de pérdida cuantil

En el siguiente ejemplo, se muestra el resultado de la predicción por lotes para un modelo optimizado de pérdida cuantil. En este caso, el modelo de previsión predijo ventas para los próximos 14 días por cada tienda.

Resultado de la predicción por lotes de muestra de un modelo optimizado de pérdida cuantil

Los valores de cuantil se proporcionan en la columna predicted_Sales.quantile_values. En este ejemplo, el modelo predijo valores en los cuantiles 0.1, 0.5 y 0.9.

Los valores de predicción se proporcionan en la columna predicted_Sales.quantile_predictions. Este es un array de valores de ventas, que se asignan a los valores cuantiles en la columna predicted_Sales.quantile_values. En la primera fila, vemos que la probabilidad del valor de ventas que es inferior a 4484.04 es del 10%. La probabilidad del valor de las ventas que es inferior a 5615.64 es del 50%. ¿La probabilidad del valor de las ventas es menor que 6853.29 es del 90%. La predicción para la primera fila, representada como un solo valor, es 5615.64.