PermutationFeatureImportanceExtensions.PermutationFeatureImportanceNonCalibrated Metodo

Riferimento

Definizione

Spazio dei nomi:: Microsoft.ML

Assembly:: Microsoft.ML.Transforms.dll

Pacchetto:: Microsoft.ML v3.0.1

Pacchetto:: Microsoft.ML v1.7.0

Pacchetto:: Microsoft.ML v2.0.0

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Importanza della funzionalità permutazione (PFI) per la classificazione binaria.

public static System.Collections.Immutable.ImmutableDictionary<string,Microsoft.ML.Data.BinaryClassificationMetricsStatistics> PermutationFeatureImportanceNonCalibrated (this Microsoft.ML.BinaryClassificationCatalog catalog, Microsoft.ML.ITransformer model, Microsoft.ML.IDataView data, string labelColumnName = "Label", bool useFeatureWeightFilter = false, int? numberOfExamplesToUse = default, int permutationCount = 1);

static member PermutationFeatureImportanceNonCalibrated : Microsoft.ML.BinaryClassificationCatalog * Microsoft.ML.ITransformer * Microsoft.ML.IDataView * string * bool * Nullable<int> * int -> System.Collections.Immutable.ImmutableDictionary<string, Microsoft.ML.Data.BinaryClassificationMetricsStatistics>

<Extension()>
Public Function PermutationFeatureImportanceNonCalibrated (catalog As BinaryClassificationCatalog, model As ITransformer, data As IDataView, Optional labelColumnName As String = "Label", Optional useFeatureWeightFilter As Boolean = false, Optional numberOfExamplesToUse As Nullable(Of Integer) = Nothing, Optional permutationCount As Integer = 1) As ImmutableDictionary(Of String, BinaryClassificationMetricsStatistics)

Parametri

catalog: BinaryClassificationCatalog

Catalogo di classificazione binaria.

model: ITransformer

Modello su cui valutare l'importanza della funzionalità.

data: IDataView

Set di dati di valutazione.

labelColumnName: String

Nome colonna etichetta. I dati della colonna devono essere Boolean.

useFeatureWeightFilter: Boolean

Usare il peso delle funzionalità per filtrare le funzionalità.

numberOfExamplesToUse: Nullable<Int32>

Limitare il numero di esempi da valutare. significa fino a ~2 bln esempi da verrà usato.

permutationCount: Int32

Numero di permutazioni da eseguire.

Restituisce

ImmutableDictionary<String,BinaryClassificationMetricsStatistics>

Il mapping di ogni funzionalità a ogni funzionalità "contributi" al punteggio.

Esempio

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.ML;

namespace Samples.Dynamic.Trainers.BinaryClassification
{
    public static class PermutationFeatureImportance
    {
        public static void Example()
        {
            // Create a new context for ML.NET operations. It can be used for
            // exception tracking and logging, as a catalog of available operations
            // and as the source of randomness.
            var mlContext = new MLContext(seed: 1);

            // Create sample data.
            var samples = GenerateData();

            // Load the sample data as an IDataView.
            var data = mlContext.Data.LoadFromEnumerable(samples);

            // Define a training pipeline that concatenates features into a vector,
            // normalizes them, and then trains a linear model.
            var featureColumns =
                new string[] { nameof(Data.Feature1), nameof(Data.Feature2) };
            var pipeline = mlContext.Transforms
                .Concatenate("Features", featureColumns)
                .Append(mlContext.Transforms.NormalizeMinMax("Features"))
                .Append(mlContext.BinaryClassification.Trainers
                .SdcaLogisticRegression());

            // Fit the pipeline to the data.
            var model = pipeline.Fit(data);

            // Transform the dataset.
            var transformedData = model.Transform(data);

            // Extract the predictor.
            var linearPredictor = model.LastTransformer;

            // Compute the permutation metrics for the linear model using the
            // normalized data.
            var permutationMetrics = mlContext.BinaryClassification
                .PermutationFeatureImportance(linearPredictor, transformedData,
                permutationCount: 30);

            // Now let's look at which features are most important to the model
            // overall. Get the feature indices sorted by their impact on AUC.
            var sortedIndices = permutationMetrics
                .Select((metrics, index) => new { index, metrics.AreaUnderRocCurve })
                .OrderByDescending(
                feature => Math.Abs(feature.AreaUnderRocCurve.Mean))
                .Select(feature => feature.index);

            Console.WriteLine("Feature\tModel Weight\tChange in AUC"
                + "\t95% Confidence in the Mean Change in AUC");
            var auc = permutationMetrics.Select(x => x.AreaUnderRocCurve).ToArray();
            foreach (int i in sortedIndices)
            {
                Console.WriteLine("{0}\t{1:0.00}\t{2:G4}\t{3:G4}",
                    featureColumns[i],
                    linearPredictor.Model.SubModel.Weights[i],
                    auc[i].Mean,
                    1.96 * auc[i].StandardError);
            }

            // Expected output:
            //  Feature     Model Weight Change in AUC  95% Confidence in the Mean Change in AUC
            //  Feature2        35.15     -0.387        0.002015
            //  Feature1        17.94     -0.1514       0.0008963
        }

        private class Data
        {
            public bool Label { get; set; }

            public float Feature1 { get; set; }

            public float Feature2 { get; set; }
        }

        /// <summary>
        /// Generate an enumerable of Data objects, creating the label as a simple
        /// linear combination of the features.
        /// </summary>
        /// <param name="nExamples">The number of examples.</param>
        /// <param name="bias">The bias, or offset, in the calculation of the label.
        /// </param>
        /// <param name="weight1">The weight to multiply the first feature with to
        /// compute the label.</param>
        /// <param name="weight2">The weight to multiply the second feature with to
        /// compute the label.</param>
        /// <param name="seed">The seed for generating feature values and label
        /// noise.</param>
        /// <returns>An enumerable of Data objects.</returns>
        private static IEnumerable<Data> GenerateData(int nExamples = 10000,
            double bias = 0, double weight1 = 1, double weight2 = 2, int seed = 1)
        {
            var rng = new Random(seed);
            for (int i = 0; i < nExamples; i++)
            {
                var data = new Data
                {
                    Feature1 = (float)(rng.Next(10) * (rng.NextDouble() - 0.5)),
                    Feature2 = (float)(rng.Next(10) * (rng.NextDouble() - 0.5)),
                };

                // Create a noisy label.
                var value = (float)(bias + weight1 * data.Feature1 + weight2 *
                    data.Feature2 + rng.NextDouble() - 0.5);

                data.Label = Sigmoid(value) > 0.5;
                yield return data;
            }
        }

        private static double Sigmoid(double x) => 1.0 / (1.0 + Math.Exp(-1 * x));
    }
}

Commenti

L'importanza della funzionalità di permutazione (PFI) è una tecnica per determinare l'importanza globale delle funzionalità in un modello di Machine Learning sottoposto a training. PFI è una tecnica semplice ma potente motivata da Breiman nella sua carta Random Forest, sezione 10 (Breiman). "Foreste casuali". Machine Learning, 2001. Il vantaggio del metodo PFI è che è un modello agnostico, che funziona con qualsiasi modello che può essere valutato e può usare qualsiasi set di dati, non solo il set di training, per calcolare le metriche di importanza delle funzionalità.

PFI funziona prendendo un set di dati etichettato, scegliendo una funzionalità e modificando i valori per tale funzionalità in tutti gli esempi, in modo che ogni esempio abbia ora un valore casuale per la funzionalità e i valori originali per tutte le altre funzionalità. La metrica di valutazione (ad esempio, AUC) viene quindi calcolata per questo set di dati modificato e la modifica nella metrica di valutazione dal set di dati originale viene calcolata. Maggiore è la modifica nella metrica di valutazione, più importante è la funzionalità per il modello. PFI funziona eseguendo questa analisi di permutazione in tutte le funzionalità di un modello, una dopo l'altra.

In questa implementazione, PFI calcola la modifica in tutte le possibili metriche di valutazione della classificazione binaria per ogni funzionalità e viene restituito un ImmutableArray oggetto di BinaryClassificationMetrics oggetti. Per un esempio di utilizzo di questi risultati, vedere l'esempio seguente per analizzare l'importanza della funzionalità di un modello.

Si applica a

Condividi tramite