Spiegazione delle previsioni

Questa pagina descrive come utilizzare l'importanza delle caratteristiche per avere visibilità sul modo in cui il modello esegue le previsioni.

Per ulteriori informazioni su AI Explanations, consulta Introduzione ad AI Explanations per AI Platform.

Introduzione

Quando utilizzi un modello di machine learning per prendere decisioni aziendali, è importante capire in che modo i dati di addestramento hanno contribuito al modello finale e in che modo il modello ha raggiunto le singole previsioni. Questa comprensione ti aiuta a garantire che il tuo modello sia giusto e preciso.

AutoML Tables fornisce l'importanza delle caratteristiche, a volte chiamata attribuzione delle caratteristiche, che ti consente di vedere quali caratteristiche hanno contribuito maggiormente all'addestramento del modello (importanza delle caratteristiche del modello) e alle singole previsioni (importanza delle caratteristiche locali).

AutoML Tables calcola l'importanza delle caratteristiche utilizzando il metodo Shapley campionato. Per ulteriori informazioni sulla spiegabilità del modello, consulta Introduzione alle spiegazioni IA.

Importanza delle caratteristiche del modello

L'importanza delle caratteristiche del modello ti aiuta a garantire che le caratteristiche su cui si basa l'addestramento del modello siano pertinenti per i tuoi dati e i problemi aziendali. Tutte le caratteristiche con un valore elevato di importanza delle caratteristiche devono rappresentare un indicatore valido per la previsione ed essere incluse in modo coerente nelle richieste di previsione.

L'importanza delle caratteristiche del modello viene indicata in percentuale per ciascuna caratteristica: maggiore è la percentuale, più la caratteristica ha influito sull'addestramento del modello.

Ottenere l'importanza delle caratteristiche del modello

Console

Per visualizzare i valori di importanza delle caratteristiche del modello utilizzando la console Google Cloud:

  1. Vai alla pagina AutoML Tables nella console Google Cloud.

    Vai alla pagina AutoML Tables

  2. Seleziona la scheda Modelli nel riquadro di navigazione a sinistra, poi seleziona il modello per cui vuoi visualizzare le metriche di valutazione.

  3. Apri la scheda Valuta.

  4. Scorri verso il basso per vedere il grafico Importanza delle caratteristiche.

Pagina di valutazione AutoML Tables

REST

Per ottenere i valori di importanza delle caratteristiche per un modello, utilizza il metodo model.get.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • endpoint: automl.googleapis.com per la località globale e eu-automl.googleapis.com per la regione dell'UE.
  • project-id: il tuo ID progetto Google Cloud.
  • location: la località per la risorsa: us-central1 per Globale o eu per l'Unione Europea.
  • model-id: l'ID del modello per cui vuoi ottenere le informazioni sull'importanza delle caratteristiche. Ad esempio, TBL543.

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Esegui questo comando:

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

PowerShell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id" | Select-Object -Expand Content
I valori di importanza delle caratteristiche per ogni colonna vengono restituiti nell'oggetto 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

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Scopri di più.


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

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Scopri di più.

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 libreria client per AutoML Tables include metodi Python aggiuntivi che semplificano l'utilizzo dell'API AutoML Tables. Questi metodi fanno riferimento a set di dati e modelli per nome anziché per ID. I nomi dei set di dati e dei modelli devono essere univoci. Per maggiori informazioni, consulta la documentazione di riferimento per i client.

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Scopri di più.

# 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

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 == automl.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(f"Model name: {model.name}")
print("Model id: {}".format(model.name.split("/")[-1]))
print(f"Model display name: {model.display_name}")
print("Features of top importance:")
for feat in feat_list[:feat_to_show]:
    print(feat)
print(f"Model create time: {model.create_time}")
print(f"Model deployment state: {deployment_state}")

Importanza delle caratteristiche locali

L'importanza delle caratteristiche locali ti offre visibilità su come le singole caratteristiche in una specifica richiesta di previsione hanno influito sulla previsione risultante.

Per arrivare a ogni valore di importanza delle caratteristiche locali, viene prima calcolato il punteggio di previsione di riferimento. I valori di riferimento vengono calcolati dai dati di addestramento, utilizzando il valore mediano per le caratteristiche numeriche e la modalità per le caratteristiche categoriche. La previsione generata dai valori di riferimento è il punteggio di previsione di riferimento.

Per i modelli di classificazione, l'importanza delle caratteristiche locali indica quanto ogni caratteristica è stata aggiunta o sottratta dalla probabilità assegnata alla classe con il punteggio più alto, rispetto al punteggio di previsione di base. I valori dei punteggi sono compresi tra 0,0 e 1,0, quindi l'importanza delle caratteristiche locali per i modelli di classificazione è sempre compresa tra -1,0 e 1,0 (incluso).

Per i modelli di regressione, l'importanza delle caratteristiche locali per una previsione indica in che misura ciascuna caratteristica è stata aggiunta o sottratta dal risultato rispetto al punteggio di previsione di riferimento.

L'importanza delle caratteristiche locali è disponibile sia per le previsioni online che per quelle batch.

Ottenere l'importanza delle caratteristiche locali per le previsioni online

Console

Per ottenere i valori di importanza delle caratteristiche locali per una previsione online utilizzando la console Google Cloud, segui i passaggi descritti in Ottenere una previsione online, assicurandoti di selezionare la casella di controllo Genera importanza delle caratteristiche.

Casella di controllo per l'importanza delle caratteristiche di AutoML Tables

REST

Per ottenere l'importanza delle caratteristiche locali per una richiesta di previsione online, utilizza il metodo model.predict, impostando il parametro feature_importance su true.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • endpoint: automl.googleapis.com per la località globale e eu-automl.googleapis.com per la regione dell'UE.
  • project-id: il tuo ID progetto Google Cloud.
  • location: la località per la risorsa: us-central1 per Globale o eu per l'Unione Europea.
  • model-id: l'ID del modello. Ad esempio, TBL543.
  • valueN: i valori di ogni colonna, nell'ordine corretto.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "x-goog-user-project: project-id" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:predict"

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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
I risultati relativi all'importanza delle caratteristiche vengono restituiti nell'oggetto "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"
  }
],

Quando il valore di importanza delle caratteristiche di una colonna è 0, questa non viene visualizzata per quella colonna.

Java

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Scopri di più.

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

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Scopri di più.


/**
 * 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);

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 libreria client per AutoML Tables include metodi Python aggiuntivi che semplificano l'utilizzo dell'API AutoML Tables. Questi metodi fanno riferimento a set di dati e modelli per nome anziché per ID. I nomi dei set di dati e dei modelli devono essere univoci. Per maggiori informazioni, consulta la documentazione di riferimento per i client.

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Scopri di più.

# 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(f"Predicted class name: {result.tables.value}")
    print(f"Predicted class score: {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)

Ottenere l'importanza delle caratteristiche locali per le previsioni batch

Console

Per ottenere i valori di importanza delle caratteristiche locali per una previsione batch utilizzando la console Google Cloud, segui i passaggi in Richiesta di una previsione batch, assicurandoti di selezionare la casella di controllo Genera importanza delle caratteristiche.

Casella di controllo per l'importanza delle caratteristiche di AutoML Tables

L'importanza delle caratteristiche viene restituita aggiungendo una nuova colonna per ogni elemento, denominata feature_importance.<feature_name>.

REST

Per ottenere l'importanza delle caratteristiche locali per una richiesta di previsione batch, utilizza il metodo model.batchPredict, impostando il parametro feature_importance su true.

L'esempio seguente utilizza BigQuery per i dati e i risultati delle richieste; utilizzi lo stesso parametro aggiuntivo per le richieste che utilizzano Cloud Storage.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

  • endpoint: automl.googleapis.com per la località globale e eu-automl.googleapis.com per la regione dell'UE.
  • project-id: il tuo ID progetto Google Cloud.
  • location: la località per la risorsa: us-central1 per Globale o eu per l'Unione Europea.
  • model-id: l'ID del modello. Ad esempio, TBL543.
  • dataset-id: l'ID del set di dati BigQuery in cui si trovano i dati di previsione.
  • table-id: l'ID della tabella BigQuery in cui si trovano i dati di previsione.

    AutoML Tables crea una sottocartella per i risultati della previsione denominata prediction-<model_name>-<timestamp> in project-id.dataset-id.table-id.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "x-goog-user-project: project-id" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://endpoint/v1beta1/projects/project-id/locations/location/models/model-id:batchPredict"

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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 previsione batch è un'operazione a lunga esecuzione. Puoi eseguire il polling dello stato dell'operazione o attendere il ritorno dell'operazione. Scopri di più.

L'importanza delle caratteristiche viene restituita aggiungendo una nuova colonna per ogni elemento, denominata feature_importance.<feature_name>.

Considerazioni sull'utilizzo dell'importanza delle caratteristiche locali:

  • I risultati sull'importanza delle caratteristiche locali sono disponibili solo per i modelli addestrati a partire dal 15 novembre 2019.

  • L'abilitazione dell'importanza delle caratteristiche locali in una richiesta di previsione batch con più di 1.000.000 di righe o 300 colonne non è supportata.

  • Ogni valore di importanza delle caratteristiche locali mostra solo l'impatto della caratteristica sulla previsione per la riga in questione. Per comprendere il comportamento complessivo del modello, utilizza l'importanza delle caratteristiche del modello.

  • I valori di importanza delle caratteristiche locali sono sempre relativi al valore di riferimento. Assicurati di fare riferimento al valore di riferimento quando valuti i risultati relativi all'importanza delle caratteristiche locali. Il valore di riferimento è disponibile solo nella console Google Cloud.

  • I valori di importanza delle caratteristiche locali dipendono interamente dal modello e dai dati utilizzati per addestrare il modello. Possono identificare solo i pattern trovati dal modello nei dati e non rilevare alcuna relazione fondamentale. Pertanto, la presenza di un'importanza elevata per una determinata caratteristica non dimostra una relazione tra quest'ultima e il target, ma indica semplicemente che il modello utilizza la caratteristica nelle sue previsioni.

  • Se una previsione include dati che non rientrano completamente nell'intervallo dei dati di addestramento, l'importanza delle caratteristiche locali potrebbe non fornire risultati significativi.

  • La generazione dell'importanza delle caratteristiche aumenta il tempo e le risorse di calcolo necessari per la previsione. La richiesta utilizza una quota diversa da quella per le richieste di previsione senza importanza delle caratteristiche. Scopri di più.

  • I valori di importanza delle caratteristiche da soli non indicano se il tuo modello è equo, imparziale o di qualità audio. Valuta attentamente il set di dati, la procedura e le metriche di valutazione di addestramento, oltre all'importanza delle caratteristiche.