Explicación sobre las predicciones

En esta página, se describe cómo puedes usar la importancia de las características para obtener visibilidad sobre cómo el modelo realiza sus predicciones.

Si deseas obtener más información sobre las explicaciones de IA, consulta Introducción a las explicaciones de IA para AI Platform.

Introducción

Cuando usas un modelo de aprendizaje automático para tomar decisiones empresariales, es importante comprender cómo contribuyeron tus datos de entrenamiento al modelo final y cómo el modelo realizó las predicciones individuales. Esta comprensión te ayuda a garantizar que tu modelo sea justo y preciso.

AutoML Tables proporciona importancia de las características, a veces llamados atribuciones de las características, lo que te permite ver qué características contribuyeron en mayor grado al entrenamiento del modelo (importancia de las características del modelo) y a las predicciones individuales (importancia de las características locales).

Con AutoML Tables se calcula la importancia de las características mediante el método de Shapley con muestreo. Para obtener más información sobre la explicación del modelo, consulta la página acerca de la introducción a las explicaciones de IA.

Importancia de los atributos del modelo

La importancia de los atributos del modelo te ayuda a asegurarte de que el entrenamiento del modelo informado tenga sentido para tus datos y problemas comerciales. Todos los atributos con un valor de importancia de atributo alto deben representar una señal válida de predicción y poder incluirse de manera coherente en tus solicitudes de predicción.

La importancia de las características del modelo se proporciona como un porcentaje para cada característica: cuanto más alto sea el porcentaje, más fuerte será el entrenamiento del modelo.

Obtén la importancia de las características del modelo

Console

Para ver los valores de importancia de las características de tu modelo mediante Google Cloud Console, haz lo siguiente:

  1. Ve a la página de AutoML Tables en Google Cloud Console.

    Ir a la página AutoML Tables

  2. Selecciona la pestaña Modelos en el panel de navegación izquierdo y selecciona el modelo del que deseas obtener las métricas de evaluación.

  3. Abre la pestaña Evaluar (Evaluate).

  4. Desplázate hacia abajo para ver el gráfico Importancia de las características.

AutoML Tables evalúa la página

LÍNEA DE REST Y CMD

Para obtener los valores de importancia de las características de un modelo, usa el método model.get.

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • endpoint: automl.googleapis.com para la ubicación global y eu-automl.googleapis.com para la región de la UE
  • project-id: Es el ID de tu proyecto de Google Cloud
  • location: la ubicación del recurso: us-central1 para la global o eu para la Unión Europea.
  • model-id: el ID del modelo del que deseas obtener información de la importancia de las características. Por ejemplo, TBL543

Método HTTP y URL:

GET https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id

PowerShell

Ejecuta el siguiente comando:

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

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id" | Select-Object -Expand Content
Los valores de importancia de las características de cada columna se muestran en el objeto TablesModelColumnInfo.
{
  "name": "projects/292381/locations/us-central1/models/TBL543",
  "displayName": "Quickstart_Model",
  ...
  "tablesModelMetadata": {
    "targetColumnSpec": {
    ...
    },
    "inputFeatureColumnSpecs": [
    ...
    ],
    "optimizationObjective": "MAXIMIZE_AU_ROC",
    "tablesModelColumnInfo": [
      {
        "columnSpecName": "projects/292381/locations/us-central1/datasets/TBL543/tableSpecs/246/columnSpecs/331",
        "columnDisplayName": "Contact",
        "featureImportance": 0.093201876
      },
      {
        "columnSpecName": "projects/292381/locations/us-central1/datasets/TBL543/tableSpecs/246/columnSpecs/638",
        "columnDisplayName": "Month",
        "featureImportance": 0.215029223
      },
      ...
    ],
    "trainBudgetMilliNodeHours": "1000",
    "trainCostMilliNodeHours": "1000",
    "classificationType": "BINARY",
    "predictionSampleRows": [
    ...
    ],
    "splitPercentageConfig": {
    ...
    }
  },
  "creationState": "CREATED",
  "deployedModelSizeBytes": "1160941568"
}

Java

Si tus recursos se encuentran en la región de la UE, debes establecer el extremo de manera explícita. Más información


import com.google.cloud.automl.v1beta1.AutoMlClient;
import com.google.cloud.automl.v1beta1.Model;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.TablesModelColumnInfo;
import io.grpc.StatusRuntimeException;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class TablesGetModel {

  public static void main(String[] args) throws IOException, StatusRuntimeException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String region = "YOUR_REGION";
    String modelId = "YOUR_MODEL_ID";
    getModel(projectId, region, modelId);
  }

  // Demonstrates using the AutoML client to get model details.
  public static void getModel(String projectId, String computeRegion, String modelId)
      throws IOException, StatusRuntimeException {
    // 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 (AutoMlClient client = AutoMlClient.create()) {

      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, computeRegion, modelId);

      // Get complete detail of the model.
      Model model = client.getModel(modelFullId);

      // Display the model information.
      System.out.format("Model name: %s%n", model.getName());
      System.out.format(
          "Model Id: %s\n", model.getName().split("/")[model.getName().split("/").length - 1]);
      System.out.format("Model display name: %s%n", model.getDisplayName());
      System.out.format("Dataset Id: %s%n", model.getDatasetId());
      System.out.println("Tables Model Metadata: ");
      System.out.format(
          "\tTraining budget: %s%n", model.getTablesModelMetadata().getTrainBudgetMilliNodeHours());
      System.out.format(
          "\tTraining cost: %s%n", model.getTablesModelMetadata().getTrainBudgetMilliNodeHours());

      DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
      String createTime =
          dateFormat.format(new java.util.Date(model.getCreateTime().getSeconds() * 1000));
      System.out.format("Model create time: %s%n", createTime);

      System.out.format("Model deployment state: %s%n", model.getDeploymentState());

      // Get features of top importance
      for (TablesModelColumnInfo info :
          model.getTablesModelMetadata().getTablesModelColumnInfoList()) {
        System.out.format(
            "Column: %s - Importance: %.2f%n",
            info.getColumnDisplayName(), info.getFeatureImportance());
      }
    }
  }
}

Node.js

Si tus recursos se encuentran en la región de la UE, debes establecer el extremo de manera explícita. Más información.

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

/**
 * Demonstrates using the AutoML client to get model details.
 * 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 modelId = '[MODEL_ID]' e.g., "TBL4704590352927948800";

// Get the full path of the model.
const modelFullId = client.modelPath(projectId, computeRegion, modelId);

// Get complete detail of the model.
client
  .getModel({name: modelFullId})
  .then(responses => {
    const model = responses[0];

    // Display the model information.
    console.log(`Model name: ${model.name}`);
    console.log(`Model Id: ${model.name.split('/').pop(-1)}`);
    console.log(`Model display name: ${model.displayName}`);
    console.log(`Dataset Id: ${model.datasetId}`);
    console.log('Tables model metadata: ');
    console.log(
      `\tTraining budget: ${model.tablesModelMetadata.trainBudgetMilliNodeHours}`
    );
    console.log(
      `\tTraining cost: ${model.tablesModelMetadata.trainCostMilliNodeHours}`
    );
    console.log(`Model deployment state: ${model.deploymentState}`);
  })
  .catch(err => {
    console.error(err);
  });

Python

La biblioteca cliente de AutoML Tables incluye métodos adicionales de Python que simplifican el uso de la API de AutoML Tables. Estos métodos hacen referencia a conjuntos de datos y modelos por nombre en lugar de ID. El conjunto de datos y los nombres de los modelos deben ser únicos. Para obtener más información, consulta la página de referencia del cliente.

Si tus recursos se encuentran en la región de la UE, debes establecer el extremo de manera explícita. Más información

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_display_name = 'MODEL_DISPLAY_NAME_HERE'

from google.cloud import automl_v1beta1 as automl
from google.cloud.automl_v1beta1 import enums

client = automl.TablesClient(project=project_id, region=compute_region)

# Get complete detail of the model.
model = client.get_model(model_display_name=model_display_name)

# Retrieve deployment state.
if model.deployment_state == enums.Model.DeploymentState.DEPLOYED:
    deployment_state = "deployed"
else:
    deployment_state = "undeployed"

# get features of top importance
feat_list = [
    (column.feature_importance, column.column_display_name)
    for column in model.tables_model_metadata.tables_model_column_info
]
feat_list.sort(reverse=True)
if len(feat_list) < 10:
    feat_to_show = len(feat_list)
else:
    feat_to_show = 10

# Display the model information.
print("Model name: {}".format(model.name))
print("Model id: {}".format(model.name.split("/")[-1]))
print("Model display name: {}".format(model.display_name))
print("Features of top importance:")
for feat in feat_list[:feat_to_show]:
    print(feat)
print("Model create time:")
print("\tseconds: {}".format(model.create_time.seconds))
print("\tnanos: {}".format(model.create_time.nanos))
print("Model deployment state: {}".format(deployment_state))

Importancia del atributo local

La importancia de las características locales te permite ver cómo las funciones individuales de una solicitud de predicción específica afectaron la predicción resultante.

Para llegar a cada valor de importancia de los atributos locales, primero se calcula la puntuación de predicción del modelo de referencia. Los valores del modelo de referencia se calculan a partir de los datos de entrenamiento, y se usa el valor de la mediana para los atributos numéricos y el modo para los atributos categóricos. La predicción que se genera a partir de los valores del modelo de referencia es la puntuación de predicción del modelo de referencia.

Para los modelos de clasificación, la importancia de los atributos locales indica cuánto agregó cada atributo a la probabilidad asignada a la clase con la puntuación más alta o cuánto quitó en comparación con la puntuación de predicción del modelo de referencia.

En el caso de los modelos de regresión, la importancia de los atributos locales para una predicción te indica cuánto agregó cada atributo al resultado o cuánto quitó en comparación con la puntuación de predicción del modelo de referencia.

La importancia de las características locales está disponible para las predicciones en línea y por lotes.

Obtén la importancia de las características locales para las predicciones en línea

Console

Si deseas obtener los valores de la importancia de las características locales de una predicción en línea mediante Google Cloud Console, sigue los pasos que se encuentran en Obtén una predicción en línea y asegúrate de marcar la casilla de verificación Generar importancia de las características.

Casilla de verificación de la importancia de las características de AutoML Tables

LÍNEA DE REST Y CMD

Si deseas obtener la importancia de las características locales de una solicitud de predicción en línea, usa el método model.predict y configura el parámetro feature_importance como verdadero.

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • endpoint: automl.googleapis.com para la ubicación global y eu-automl.googleapis.com para la región de la UE
  • project-id: Es el ID de tu proyecto de Google Cloud
  • location: la ubicación del recurso: us-central1 para la global o eu para la Unión Europea
  • model-id: El ID del modelo. Por ejemplo, TBL543
  • valueN: los valores de cada columna, en el orden correcto.

Método HTTP y URL:

POST https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:predict

Cuerpo JSON de la solicitud:

{
  "payload": {
    "row": {
      "values": [
        value1, value2,...
      ]
    }
  }
  "params": {
    "feature_importance": "true"
  }
}

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 application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:predict

PowerShell

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

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

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:predict" | Select-Object -Expand Content
Los resultados de la importancia de las características se muestran en el objeto `tablesModelColumnInfo`.
"tablesModelColumnInfo": [
  {
     "columnSpecName": "projects/2381/locations/us-central1/datasets/TBL8440/tableSpecs/766336/columnSpecs/4704",
     "columnDisplayName": "Promo",
     "featureImportance": 1626.5464
  },
  {
     "columnSpecName": "projects/2381/locations/us-central1/datasets/TBL8440/tableSpecs/766336/columnSpecs/6800",
     "columnDisplayName": "Open",
     "featureImportance": -7496.5405
  },
  {
     "columnSpecName": "projects/2381/locations/us-central1/datasets/TBL8440/tableSpecs/766336/columnSpecs/9824",
     "columnDisplayName": "StateHoliday"
  }
],

Cuando una columna tiene un valor de importancia de atributo de 0, no se muestra la importancia de la función para esa columna.

Java

Si tus recursos se encuentran en la región de la UE, debes establecer el extremo de manera explícita. Más información

import com.google.cloud.automl.v1beta1.AnnotationPayload;
import com.google.cloud.automl.v1beta1.ExamplePayload;
import com.google.cloud.automl.v1beta1.ModelName;
import com.google.cloud.automl.v1beta1.PredictRequest;
import com.google.cloud.automl.v1beta1.PredictResponse;
import com.google.cloud.automl.v1beta1.PredictionServiceClient;
import com.google.cloud.automl.v1beta1.Row;
import com.google.cloud.automl.v1beta1.TablesAnnotation;
import com.google.protobuf.Value;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

class TablesPredict {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    // Values should match the input expected by your model.
    List<Value> values = new ArrayList<>();
    // values.add(Value.newBuilder().setBoolValue(true).build());
    // values.add(Value.newBuilder().setNumberValue(10).build());
    // values.add(Value.newBuilder().setStringValue("YOUR_STRING").build());
    predict(projectId, modelId, values);
  }

  static void predict(String projectId, String modelId, List<Value> values) throws IOException {
    // 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 (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);
      Row row = Row.newBuilder().addAllValues(values).build();
      ExamplePayload payload = ExamplePayload.newBuilder().setRow(row).build();

      // Feature importance gives you visibility into how the features in a specific prediction
      // request informed the resulting prediction. For more info, see:
      // https://cloud.google.com/automl-tables/docs/features#local
      PredictRequest request =
          PredictRequest.newBuilder()
              .setName(name.toString())
              .setPayload(payload)
              .putParams("feature_importance", "true")
              .build();

      PredictResponse response = client.predict(request);

      System.out.println("Prediction results:");
      for (AnnotationPayload annotationPayload : response.getPayloadList()) {
        TablesAnnotation tablesAnnotation = annotationPayload.getTables();
        System.out.format(
            "Classification label: %s%n", tablesAnnotation.getValue().getStringValue());
        System.out.format("Classification score: %.3f%n", tablesAnnotation.getScore());
        // Get features of top importance
        tablesAnnotation
            .getTablesModelColumnInfoList()
            .forEach(
                info ->
                    System.out.format(
                        "\tColumn: %s - Importance: %.2f%n",
                        info.getColumnDisplayName(), info.getFeatureImportance()));
      }
    }
  }
}

Node.js

Si tus recursos se encuentran en la región de la UE, debes establecer el extremo de manera explícita. Más información


/**
 * Demonstrates using the AutoML client to request prediction from
 * automl tables using csv.
 * 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 modelId = '[MODEL_ID]' e.g., "TBL000000000000";
// const inputs = [{ numberValue: 1 }, { stringValue: 'value' }, { stringValue: 'value2' } ...]

const automl = require('@google-cloud/automl');

// Create client for prediction service.
const automlClient = new automl.v1beta1.PredictionServiceClient();

// Get the full path of the model.
const modelFullId = automlClient.modelPath(projectId, computeRegion, modelId);

inputs = JSON.parse(inputs);

async function predict() {
  // Set the payload by giving the row values.
  const payload = {
    row: {
      values: inputs,
    },
  };

  // Params is additional domain-specific parameters.
  // Currently there is no additional parameters supported.
  const [response] = await automlClient.predict({
    name: modelFullId,
    payload: payload,
    params: {feature_importance: true},
  });
  console.log('Prediction results:');

  for (const result of response.payload) {
    console.log(`Predicted class name: ${result.displayName}`);
    console.log(`Predicted class score: ${result.tables.score}`);

    // Get features of top importance
    const featureList = result.tables.tablesModelColumnInfo.map(
      columnInfo => {
        return {
          importance: columnInfo.featureImportance,
          displayName: columnInfo.columnDisplayName,
        };
      }
    );
    // Sort features by their importance, highest importance first
    featureList.sort((a, b) => {
      return b.importance - a.importance;
    });

    // Print top 10 important features
    console.log('Features of top importance');
    console.log(featureList.slice(0, 10));
  }
}
predict();

Python

La biblioteca cliente de AutoML Tables incluye métodos adicionales de Python que simplifican el uso de la API de AutoML Tables. Estos métodos hacen referencia a conjuntos de datos y modelos por nombre en lugar de ID. El conjunto de datos y los nombres de los modelos deben ser únicos. Para obtener más información, consulta la página de referencia del cliente.

Si tus recursos se encuentran en la región de la UE, debes establecer el extremo de manera explícita. Más información

# TODO(developer): Uncomment and set the following variables
# project_id = 'PROJECT_ID_HERE'
# compute_region = 'COMPUTE_REGION_HERE'
# model_display_name = 'MODEL_DISPLAY_NAME_HERE'
# inputs = {'value': 3, ...}

from google.cloud import automl_v1beta1 as automl

client = automl.TablesClient(project=project_id, region=compute_region)

if feature_importance:
    response = client.predict(
        model_display_name=model_display_name,
        inputs=inputs,
        feature_importance=True,
    )
else:
    response = client.predict(
        model_display_name=model_display_name, inputs=inputs
    )

print("Prediction results:")
for result in response.payload:
    print(
        "Predicted class name: {}".format(result.tables.value.string_value)
    )
    print("Predicted class score: {}".format(result.tables.score))

    if feature_importance:
        # get features of top importance
        feat_list = [
            (column.feature_importance, column.column_display_name)
            for column in result.tables.tables_model_column_info
        ]
        feat_list.sort(reverse=True)
        if len(feat_list) < 10:
            feat_to_show = len(feat_list)
        else:
            feat_to_show = 10

        print("Features of top importance:")
        for feat in feat_list[:feat_to_show]:
            print(feat)

Obtén la importancia de las características locales para las predicciones por lotes

Console

Si deseas obtener los valores de la importancia de las características locales de una predicción por lotes mediante Google Cloud Console, sigue los pasos que se encuentran en Solicita una predicción por lotes y asegúrate de marcar la casilla de verificación Generar importancia de las características.

Casilla de verificación de la importancia de las características de AutoML Tables

La importancia de las características se muestra mediante el agregado de una columna nueva para cada función, llamada feature_importance.<feature_name>.

LÍNEA DE REST Y CMD

Si deseas obtener la importancia de las características locales de una solicitud de predicción por lotes, usa el método model.batchPredict y configura el parámetro feature_importance como verdadero.

En el siguiente ejemplo, se usa BigQuery para los datos de la solicitud y los resultados. Debes usar el mismo parámetro adicional en las solicitudes que usan Cloud Storage.

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • endpoint: automl.googleapis.com para la ubicación global y eu-automl.googleapis.com para la región de la UE
  • project-id: Es el ID de tu proyecto de Google Cloud
  • location: la ubicación del recurso: us-central1 para la global o eu para la Unión Europea
  • model-id: El ID del modelo. Por ejemplo, TBL543
  • dataset-id: el ID del conjunto de datos de BigQuery en el que se encuentran los datos de predicción
  • table-id: el ID de la tabla de BigQuery en la que se encuentran los datos de predicción

    AutoML Tables crea una subcarpeta para los resultados de la predicción llamada prediction-<model_name>-<timestamp> en project-id.dataset-id.table-id.

Método HTTP y URL:

POST https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict

Cuerpo JSON de la solicitud:

{
  "inputConfig": {
    "bigquerySource": {
      "inputUri": "bq://project-id.dataset-id.table-id"
    },
  },
  "outputConfig": {
    "bigqueryDestination": {
      "outputUri": "bq://project-id"
    },
  },
  "params": {"feature_importance": "true"}
}

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 application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict

PowerShell

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

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

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict" | Select-Object -Expand Content
La predicción por lotes es una operación de larga duración. Puedes consultar el estado de la operación o esperar a que esta se muestre. Más información

La importancia de las características se muestra mediante el agregado de una columna nueva para cada función, llamada feature_importance.<feature_name>.

Consideraciones para usar la importancia de los atributos locales:

  • Los resultados de la importancia de los atributos locales solo están disponibles para entrenamientos de modelos a partir del 15 de noviembre de 2019.

  • No se admite la habilitación de la importancia de las características locales en una solicitud de predicción por lotes con más de 1,000,000 filas o 300 columnas.

  • Cada valor de importancia de los atributos locales muestra solo cuánto afectó el atributo a la predicción de esa fila. Para comprender el comportamiento general del modelo, usa la importancia de las características del modelo.

  • Los valores de importancia de los atributos locales siempre se relacionan con el valor del modelo de referencia. Asegúrate de referenciar el valor del modelo de referencia cuando evalúes tus resultados de importancia de los atributos locales. El valor del modelo de referencia solo está disponible en Cloud Console.

  • Los valores de importancia de los atributos locales dependen en su totalidad del modelo y los datos que se usaron para entrenar el modelo. Solo pueden distinguir los patrones que el modelo encontró en los datos y no pueden detectar ninguna relación fundamental en los datos. Por lo tanto, la presencia de una importancia de los atributos alta para un atributo determinado no demuestra una relación entre ese atributo y el objetivo; solo muestra que el modelo usa el atributo en sus predicciones.

  • Si una predicción incluye datos que están completamente fuera del rango de los datos de entrenamiento, es posible que la importancia de las características locales no proporcione resultados significativos.

  • La generación de la importancia de los atributos aumenta el tiempo y los recursos de procesamiento necesarios para tu predicción. Además, tu solicitud usa una cuota diferente a la de las solicitudes de predicción sin la importancia de las características. Más información

  • Los valores de importancia de los atributos por sí solos no indican si tu modelo es equitativo, imparcial o de buena calidad. Debes evaluar con cuidado el conjunto de datos de entrenamiento, el procedimiento y las métricas de evaluación, además de la importancia de los atributos.