Questa versione precedente di AutoML Tables è deprecata e non sarà più disponibile su Google Cloud dopo il 31 marzo 2024. Tutte le funzionalità della versione precedente di AutoML Tables e le nuove funzionalità sono disponibili sulla piattaforma Vertex AI. Consulta Eseguire la migrazione a Vertex AI per scoprire come eseguire la migrazione delle risorse.

Questa pagina è stata tradotta dall'API Cloud Translation.

Spiegazione delle previsioni

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

Per ulteriori informazioni su AI Explanations, consulta Introduzione ad AI Explanations for 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 è arrivato alle singole previsioni. Questa comprensione ti aiuta a garantire che il tuo modello sia equo e accurato.

AutoML Tables offre l'importanza delle caratteristiche, a volte chiamate attribuzioni delle caratteristiche, il che 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 saperne di più sulla spiegabilità del modello, consulta Introduzione a AI Explains.

Importanza delle caratteristiche del modello

L'importanza delle caratteristiche del modello aiuta a garantire che le caratteristiche che hanno determinato l'addestramento del modello abbiano senso per i dati e il problema aziendale. Tutte le caratteristiche con un valore elevato di importanza delle caratteristiche devono rappresentare un indicatore valido per la previsione ed essere in grado di essere incluse in modo coerente nelle richieste di previsione.

L'importanza delle caratteristiche del modello è fornita sotto forma percentuale per ogni caratteristica: più alta è la percentuale, maggiore è stato l'impatto della caratteristica 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:

Vai alla pagina AutoML Tables nella console Google Cloud.

Vai alla pagina AutoML Tables
Nel riquadro di navigazione a sinistra, seleziona la scheda Modelli e seleziona il modello per il quale vuoi ottenere le metriche di valutazione.
Apri la scheda Valuta.
Scorri verso il basso per visualizzare 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: l'ID del tuo progetto Google Cloud.
location: la località della risorsa: us-central1 per tutto il mondo o eu per l'Unione europea.
model-id: l'ID del modello per il quale 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:

curl

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. Ulteriori informazioni


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. Ulteriori informazioni

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 ulteriori metodi Python 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 sezione Riferimento cliente.

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Ulteriori informazioni

# 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}")

Feature importance locale

L'importanza delle caratteristiche locali ti consente di capire in che modo 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 innanzitutto calcolato il punteggio di previsione di riferimento. I valori di riferimento vengono calcolati a partire 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 corrisponde al 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 riferimento. 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 (inclusi).

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

L'importanza delle caratteristiche locali è disponibile per le previsioni sia online che 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 dell'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: l'ID del tuo progetto Google Cloud.
location: la località della risorsa: us-central1 per tutto il mondo o eu per l'Unione europea.
model-id: l'ID del modello. Ad esempio, TBL543.
valueN: i valori per 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:

curl

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 una colonna ha un valore di importanza delle caratteristiche pari a 0, l'importanza delle caratteristiche non viene visualizzata per quella colonna.

Java

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Ulteriori informazioni

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. Ulteriori informazioni


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

Se le risorse si trovano nella regione dell'UE, devi impostare esplicitamente l'endpoint. Ulteriori informazioni

# 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 descritti in Richiedere una previsione batch, assicurandoti di selezionare la casella di controllo Genera importanza delle caratteristiche.

Casella di controllo dell'importanza delle caratteristiche di AutoML Tables

L'importanza delle caratteristiche viene restituita aggiungendo una nuova colonna per ogni caratteristica, 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 delle richieste e i risultati; 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: l'ID del tuo progetto Google Cloud.
location: la località della risorsa: us-central1 per tutto il mondo 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:

curl

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 per verificare lo stato dell'operazione o attendere il suo ritorno. Ulteriori informazioni

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

Considerazioni sull'utilizzo dell'importanza delle caratteristiche locali:

I risultati relativi all'importanza delle caratteristiche locali sono disponibili solo per i modelli addestrati a partire dal 15 novembre 2019.
L'abilitazione dell'importanza delle caratteristiche locali su 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 in che misura la caratteristica ha influito sulla previsione per la riga in questione. Per comprendere il comportamento complessivo del modello, utilizza l'articolo 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 dell'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 solo rilevare i pattern trovati dal modello nei dati e non rilevano alcuna relazione fondamentale nei dati. Quindi, la presenza di un'elevata importanza delle caratteristiche per una determinata caratteristica non dimostra una relazione tra quella caratteristica e il target; mostra semplicemente che il modello sta utilizzando la caratteristica nelle sue previsioni.
Se una previsione include dati che non rientrano completamente nell'intervallo dei dati di addestramento, l'importanza locale delle caratteristiche potrebbe non fornire risultati significativi.
La generazione dell'importanza delle caratteristiche aumenta il tempo e le risorse di calcolo necessarie per la previsione. Inoltre, la tua richiesta utilizza una quota diversa rispetto alle richieste di previsione senza importanza delle caratteristiche. Ulteriori informazioni
I valori di importanza delle caratteristiche da soli non indicano se il modello è equo, imparziale o della qualità audio. Valuta attentamente il set di dati di addestramento, le procedure e le metriche di valutazione, oltre all'importanza delle caratteristiche.