Compartilhar via


PermutationFeatureImportanceExtensions.PermutationFeatureImportance Método

Definição

Sobrecargas

PermutationFeatureImportance(MulticlassClassificationCatalog, ITransformer, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para MulticlassClassificação.

PermutationFeatureImportance(RegressionCatalog, ITransformer, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Regressão.

PermutationFeatureImportance(RankingCatalog, ITransformer, IDataView, String, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Classificação.

PermutationFeatureImportance<TModel>(BinaryClassificationCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Classificação Binária.

PermutationFeatureImportance<TModel>(MulticlassClassificationCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para MulticlassClassificação.

PermutationFeatureImportance<TModel>(RegressionCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Regressão.

PermutationFeatureImportance<TModel>(RankingCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Classificação.

PermutationFeatureImportance(MulticlassClassificationCatalog, ITransformer, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para MulticlassClassificação.

public static System.Collections.Immutable.ImmutableDictionary<string,Microsoft.ML.Data.MulticlassClassificationMetricsStatistics> PermutationFeatureImportance (this Microsoft.ML.MulticlassClassificationCatalog catalog, Microsoft.ML.ITransformer model, Microsoft.ML.IDataView data, string labelColumnName = "Label", bool useFeatureWeightFilter = false, int? numberOfExamplesToUse = default, int permutationCount = 1);
static member PermutationFeatureImportance : Microsoft.ML.MulticlassClassificationCatalog * Microsoft.ML.ITransformer * Microsoft.ML.IDataView * string * bool * Nullable<int> * int -> System.Collections.Immutable.ImmutableDictionary<string, Microsoft.ML.Data.MulticlassClassificationMetricsStatistics>
<Extension()>
Public Function PermutationFeatureImportance (catalog As MulticlassClassificationCatalog, 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, MulticlassClassificationMetricsStatistics)

Parâmetros

catalog
MulticlassClassificationCatalog

O catálogo de classificação multiclasse.

model
ITransformer

O modelo no qual avaliar a importância do recurso.

data
IDataView

O conjunto de dados de avaliação.

labelColumnName
String

Nome da coluna de rótulo. Os dados da coluna devem ser KeyDataViewType.

useFeatureWeightFilter
Boolean

Use o peso dos recursos para pré-filtrar recursos.

numberOfExamplesToUse
Nullable<Int32>

Limite o número de exemplos a serem avaliados. significa que até ~2 exemplos de bln serão usados.

permutationCount
Int32

O número de permutações a serem executadas.

Retornos

Mapeamento de dicionário de cada recurso para suas "contribuições" por recurso para a pontuação.

Exemplos

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

namespace Samples.Dynamic.Trainers.MulticlassClassification
{
    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.Conversion.MapValueToKey("Label"))
                .Append(mlContext.Transforms.NormalizeMinMax("Features"))
                .Append(mlContext.MulticlassClassification.Trainers
                .SdcaMaximumEntropy());

            // 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.MulticlassClassification
                .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
            // microaccuracy.
            var sortedIndices = permutationMetrics
                .Select((metrics, index) => new { index, metrics.MicroAccuracy })
                .OrderByDescending(feature => Math.Abs(feature.MicroAccuracy.Mean))
                .Select(feature => feature.index);

            Console.WriteLine("Feature\tChange in MicroAccuracy\t95% Confidence in "
                + "the Mean Change in MicroAccuracy");

            var microAccuracy = permutationMetrics.Select(x => x.MicroAccuracy)
                .ToArray();

            foreach (int i in sortedIndices)
            {
                Console.WriteLine("{0}\t{1:G4}\t{2:G4}",
                    featureColumns[i],
                    microAccuracy[i].Mean,
                    1.96 * microAccuracy[i].StandardError);
            }

            // Expected output:
            //Feature     Change in MicroAccuracy  95% Confidence in the Mean Change in MicroAccuracy
            //Feature2     -0.1395                 0.0006567
            //Feature1     -0.05367                0.0006908
        }

        private class Data
        {
            public float 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);
            var max = bias + 4.5 * weight1 + 4.5 * weight2 + 0.5;
            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);

                if (value < max / 3)
                    data.Label = 0;
                else if (value < 2 * max / 3)
                    data.Label = 1;
                else
                    data.Label = 2;
                yield return data;
            }
        }
    }
}

Comentários

A PFI (importância do recurso de permutação) é uma técnica para determinar a importância global dos recursos em um modelo de aprendizado de máquina treinado. PFI é uma técnica simples, mas poderosa, motivada por Breiman em seu artigo da Floresta Aleatória, seção 10 (Breiman. "Florestas aleatórias". Machine Learning, 2001.) A vantagem do método PFI é que ele é agnóstico de modelo , ele funciona com qualquer modelo que pode ser avaliado - e pode usar qualquer conjunto de dados, não apenas o conjunto de treinamento, para calcular métricas de importância do recurso.

O PFI funciona usando um conjunto de dados rotulado, escolhendo um recurso e permutando os valores desse recurso em todos os exemplos, de modo que cada exemplo agora tenha um valor aleatório para o recurso e os valores originais para todos os outros recursos. A métrica de avaliação (por exemplo, microatidão) é calculada para esse conjunto de dados modificado e a alteração na métrica de avaliação do conjunto de dados original é calculada. Quanto maior a alteração na métrica de avaliação, mais importante será o recurso para o modelo. O PFI funciona executando essa análise de permutação em todos os recursos de um modelo, um após o outro.

Nesta implementação, o PFI calcula a alteração em todas as métricas de avaliação de classificação de várias classes possíveis para cada recurso e um ImmutableArray dos MulticlassClassificationMetrics objetos é retornado. Confira o exemplo abaixo para obter um exemplo de como trabalhar com esses resultados para analisar a importância do recurso de um modelo.

Aplica-se a

PermutationFeatureImportance(RegressionCatalog, ITransformer, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Regressão.

public static System.Collections.Immutable.ImmutableDictionary<string,Microsoft.ML.Data.RegressionMetricsStatistics> PermutationFeatureImportance (this Microsoft.ML.RegressionCatalog catalog, Microsoft.ML.ITransformer model, Microsoft.ML.IDataView data, string labelColumnName = "Label", bool useFeatureWeightFilter = false, int? numberOfExamplesToUse = default, int permutationCount = 1);
static member PermutationFeatureImportance : Microsoft.ML.RegressionCatalog * Microsoft.ML.ITransformer * Microsoft.ML.IDataView * string * bool * Nullable<int> * int -> System.Collections.Immutable.ImmutableDictionary<string, Microsoft.ML.Data.RegressionMetricsStatistics>
<Extension()>
Public Function PermutationFeatureImportance (catalog As RegressionCatalog, 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, RegressionMetricsStatistics)

Parâmetros

catalog
RegressionCatalog

O catálogo de regressão.

model
ITransformer

O modelo no qual avaliar a importância do recurso.

data
IDataView

O conjunto de dados de avaliação.

labelColumnName
String

Nome da coluna de rótulo. Os dados da coluna devem ser Single.

useFeatureWeightFilter
Boolean

Use o peso dos recursos para pré-filtrar recursos.

numberOfExamplesToUse
Nullable<Int32>

Limite o número de exemplos a serem avaliados. significa que até ~2 exemplos de bln serão usados.

permutationCount
Int32

O número de permutações a serem executadas.

Retornos

Mapeamento de dicionário de cada recurso para suas "contribuições" por recurso para a pontuação.

Exemplos

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

namespace Samples.Dynamic.Trainers.Regression
{
    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.Regression.Trainers.Ols());

            // 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.Regression
                .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 RMSE.
            var sortedIndices = permutationMetrics
                .Select((metrics, index) => new
                {
                    index,
                    metrics.RootMeanSquaredError
                })

                .OrderByDescending(feature => Math.Abs(
                    feature.RootMeanSquaredError.Mean))

                .Select(feature => feature.index);

            Console.WriteLine("Feature\tModel Weight\tChange in RMSE\t95%" +
                "Confidence in the Mean Change in RMSE");

            var rmse = permutationMetrics.Select(x => x.RootMeanSquaredError)
                .ToArray();

            foreach (int i in sortedIndices)
            {
                Console.WriteLine("{0}\t{1:0.00}\t{2:G4}\t{3:G4}",
                    featureColumns[i],
                    linearPredictor.Model.Weights[i],
                    rmse[i].Mean,
                    1.96 * rmse[i].StandardError);
            }

            // Expected output:
            //  Feature    Model Weight Change in RMSE  95% Confidence in the Mean Change in RMSE
            //  Feature2        9.00        4.009       0.008304
            //  Feature1        4.48        1.901       0.003351
        }

        private class Data
        {
            public float 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.
                data.Label = (float)(bias + weight1 * data.Feature1 + weight2 *
                    data.Feature2 + rng.NextDouble() - 0.5);
                yield return data;
            }
        }
    }
}

Comentários

A PFI (importância do recurso de permutação) é uma técnica para determinar a importância global dos recursos em um modelo de aprendizado de máquina treinado. PFI é uma técnica simples, mas poderosa, motivada por Breiman em seu artigo da Floresta Aleatória, seção 10 (Breiman. "Florestas aleatórias". Machine Learning, 2001.) A vantagem do método PFI é que ele é agnóstico de modelo , ele funciona com qualquer modelo que pode ser avaliado - e pode usar qualquer conjunto de dados, não apenas o conjunto de treinamento, para calcular métricas de importância do recurso.

O PFI funciona usando um conjunto de dados rotulado, escolhendo um recurso e permutando os valores desse recurso em todos os exemplos, de modo que cada exemplo agora tenha um valor aleatório para o recurso e os valores originais para todos os outros recursos. A métrica de avaliação (por exemplo, R-squared) é calculada para esse conjunto de dados modificado e a alteração na métrica de avaliação do conjunto de dados original é calculada. Quanto maior a alteração na métrica de avaliação, mais importante será o recurso para o modelo. O PFI funciona executando essa análise de permutação em todos os recursos de um modelo, um após o outro.

Nesta implementação, o PFI calcula a alteração em todas as métricas de avaliação de regressão possíveis para cada recurso e um ImmutableArray dos RegressionMetrics objetos é retornado. Confira o exemplo abaixo para obter um exemplo de como trabalhar com esses resultados para analisar a importância do recurso de um modelo.

Aplica-se a

PermutationFeatureImportance(RankingCatalog, ITransformer, IDataView, String, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Classificação.

public static System.Collections.Immutable.ImmutableDictionary<string,Microsoft.ML.Data.RankingMetricsStatistics> PermutationFeatureImportance (this Microsoft.ML.RankingCatalog catalog, Microsoft.ML.ITransformer model, Microsoft.ML.IDataView data, string labelColumnName = "Label", string rowGroupColumnName = "GroupId", bool useFeatureWeightFilter = false, int? numberOfExamplesToUse = default, int permutationCount = 1);
static member PermutationFeatureImportance : Microsoft.ML.RankingCatalog * Microsoft.ML.ITransformer * Microsoft.ML.IDataView * string * string * bool * Nullable<int> * int -> System.Collections.Immutable.ImmutableDictionary<string, Microsoft.ML.Data.RankingMetricsStatistics>
<Extension()>
Public Function PermutationFeatureImportance (catalog As RankingCatalog, model As ITransformer, data As IDataView, Optional labelColumnName As String = "Label", Optional rowGroupColumnName As String = "GroupId", Optional useFeatureWeightFilter As Boolean = false, Optional numberOfExamplesToUse As Nullable(Of Integer) = Nothing, Optional permutationCount As Integer = 1) As ImmutableDictionary(Of String, RankingMetricsStatistics)

Parâmetros

catalog
RankingCatalog

O catálogo de classificação.

model
ITransformer

O modelo no qual avaliar a importância do recurso.

data
IDataView

O conjunto de dados de avaliação.

labelColumnName
String

Nome da coluna de rótulo. Os dados da coluna devem ser Single ou KeyDataViewType.

rowGroupColumnName
String

Nome da coluna GroupId

useFeatureWeightFilter
Boolean

Use o peso dos recursos para pré-filtrar recursos.

numberOfExamplesToUse
Nullable<Int32>

Limite o número de exemplos a serem avaliados. significa que até ~2 exemplos de bln serão usados.

permutationCount
Int32

O número de permutações a serem executadas.

Retornos

Mapeamento de dicionário de cada recurso para suas "contribuições" por recurso para a pontuação.

Exemplos

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

namespace Samples.Dynamic.Trainers.Ranking
{
    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.Conversion.MapValueToKey("Label"))
                    .Append(mlContext.Transforms.Conversion.MapValueToKey(
                        "GroupId"))
                    .Append(mlContext.Transforms.NormalizeMinMax("Features"))
                    .Append(mlContext.Ranking.Trainers.FastTree());

            // 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.Ranking.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 NDCG@1.
            var sortedIndices = permutationMetrics.Select((metrics, index) => new
            {
                index,
                metrics.NormalizedDiscountedCumulativeGains
            })
                .OrderByDescending(feature => Math.Abs(
                    feature.NormalizedDiscountedCumulativeGains[0].Mean))

                .Select(feature => feature.index);

            Console.WriteLine("Feature\tChange in NDCG@1\t95% Confidence in the" +
                "Mean Change in NDCG@1");
            var ndcg = permutationMetrics.Select(
                x => x.NormalizedDiscountedCumulativeGains).ToArray();
            foreach (int i in sortedIndices)
            {
                Console.WriteLine("{0}\t{1:G4}\t{2:G4}",
                    featureColumns[i],
                    ndcg[i][0].Mean,
                    1.96 * ndcg[i][0].StandardError);
            }

            // Expected output:
            //  Feature     Change in NDCG@1    95% Confidence in the Mean Change in NDCG@1
            //  Feature2     -0.2421            0.001748
            //  Feature1     -0.0513            0.001184
        }

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

            public int GroupId { 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,
                int groupSize = 5)
        {
            var rng = new Random(seed);
            var max = bias + 4.5 * weight1 + 4.5 * weight2 + 0.5;
            for (int i = 0; i < nExamples; i++)
            {
                var data = new Data
                {
                    GroupId = i / groupSize,
                    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);
                if (value < max / 3)
                    data.Label = 0;
                else if (value < 2 * max / 3)
                    data.Label = 1;
                else
                    data.Label = 2;
                yield return data;
            }
        }
    }
}

Comentários

A PFI (importância do recurso de permutação) é uma técnica para determinar a importância global dos recursos em um modelo de aprendizado de máquina treinado. PFI é uma técnica simples, mas poderosa, motivada por Breiman em seu artigo da Floresta Aleatória, seção 10 (Breiman. "Florestas aleatórias". Machine Learning, 2001.) A vantagem do método PFI é que ele é agnóstico de modelo , ele funciona com qualquer modelo que pode ser avaliado - e pode usar qualquer conjunto de dados, não apenas o conjunto de treinamento, para calcular métricas de importância do recurso.

O PFI funciona usando um conjunto de dados rotulado, escolhendo um recurso e permutando os valores desse recurso em todos os exemplos, de modo que cada exemplo agora tenha um valor aleatório para o recurso e os valores originais para todos os outros recursos. A métrica de avaliação (por exemplo, NDCG) é calculada para esse conjunto de dados modificado e a alteração na métrica de avaliação do conjunto de dados original é calculada. Quanto maior a alteração na métrica de avaliação, mais importante será o recurso para o modelo. O PFI funciona executando essa análise de permutação em todos os recursos de um modelo, um após o outro.

Nesta implementação, o PFI calcula a alteração em todas as métricas de avaliação de classificação possíveis para cada recurso e um ImmutableArray dos RankingMetrics objetos é retornado. Confira o exemplo abaixo para obter um exemplo de como trabalhar com esses resultados para analisar a importância do recurso de um modelo.

Aplica-se a

PermutationFeatureImportance<TModel>(BinaryClassificationCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Classificação Binária.

public static System.Collections.Immutable.ImmutableArray<Microsoft.ML.Data.BinaryClassificationMetricsStatistics> PermutationFeatureImportance<TModel> (this Microsoft.ML.BinaryClassificationCatalog catalog, Microsoft.ML.ISingleFeaturePredictionTransformer<TModel> predictionTransformer, Microsoft.ML.IDataView data, string labelColumnName = "Label", bool useFeatureWeightFilter = false, int? numberOfExamplesToUse = default, int permutationCount = 1) where TModel : class;
static member PermutationFeatureImportance : Microsoft.ML.BinaryClassificationCatalog * Microsoft.ML.ISingleFeaturePredictionTransformer<'Model (requires 'Model : null)> * Microsoft.ML.IDataView * string * bool * Nullable<int> * int -> System.Collections.Immutable.ImmutableArray<Microsoft.ML.Data.BinaryClassificationMetricsStatistics> (requires 'Model : null)
<Extension()>
Public Function PermutationFeatureImportance(Of TModel As Class) (catalog As BinaryClassificationCatalog, predictionTransformer As ISingleFeaturePredictionTransformer(Of TModel), 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 ImmutableArray(Of BinaryClassificationMetricsStatistics)

Parâmetros de tipo

TModel

Parâmetros

catalog
BinaryClassificationCatalog

O catálogo de classificação binária.

predictionTransformer
ISingleFeaturePredictionTransformer<TModel>

O modelo no qual avaliar a importância do recurso.

data
IDataView

O conjunto de dados de avaliação.

labelColumnName
String

Nome da coluna de rótulo. Os dados da coluna devem ser Boolean.

useFeatureWeightFilter
Boolean

Use o peso dos recursos para pré-filtrar recursos.

numberOfExamplesToUse
Nullable<Int32>

Limite o número de exemplos a serem avaliados. significa que até ~2 exemplos de bln serão usados.

permutationCount
Int32

O número de permutações a serem executadas.

Retornos

Matriz de 'contribuições' por recurso para a pontuação.

Exemplos

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));
    }
}

Comentários

A PFI (importância do recurso de permutação) é uma técnica para determinar a importância global dos recursos em um modelo de aprendizado de máquina treinado. PFI é uma técnica simples, mas poderosa, motivada por Breiman em seu artigo da Floresta Aleatória, seção 10 (Breiman. "Florestas aleatórias". Machine Learning, 2001.) A vantagem do método PFI é que ele é agnóstico de modelo , ele funciona com qualquer modelo que pode ser avaliado - e pode usar qualquer conjunto de dados, não apenas o conjunto de treinamento, para calcular métricas de importância do recurso.

O PFI funciona usando um conjunto de dados rotulado, escolhendo um recurso e permutando os valores desse recurso em todos os exemplos, de modo que cada exemplo agora tenha um valor aleatório para o recurso e os valores originais para todos os outros recursos. A métrica de avaliação (por exemplo, AUC) é calculada para esse conjunto de dados modificado e a alteração na métrica de avaliação do conjunto de dados original é calculada. Quanto maior a alteração na métrica de avaliação, mais importante será o recurso para o modelo. O PFI funciona executando essa análise de permutação em todos os recursos de um modelo, um após o outro.

Nesta implementação, o PFI calcula a alteração em todas as possíveis métricas de avaliação de classificação binária para cada recurso e um ImmutableArray dos BinaryClassificationMetrics objetos é retornado. Confira o exemplo abaixo para obter um exemplo de como trabalhar com esses resultados para analisar a importância do recurso de um modelo.

Aplica-se a

PermutationFeatureImportance<TModel>(MulticlassClassificationCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para MulticlassClassificação.

public static System.Collections.Immutable.ImmutableArray<Microsoft.ML.Data.MulticlassClassificationMetricsStatistics> PermutationFeatureImportance<TModel> (this Microsoft.ML.MulticlassClassificationCatalog catalog, Microsoft.ML.ISingleFeaturePredictionTransformer<TModel> predictionTransformer, Microsoft.ML.IDataView data, string labelColumnName = "Label", bool useFeatureWeightFilter = false, int? numberOfExamplesToUse = default, int permutationCount = 1) where TModel : class;
static member PermutationFeatureImportance : Microsoft.ML.MulticlassClassificationCatalog * Microsoft.ML.ISingleFeaturePredictionTransformer<'Model (requires 'Model : null)> * Microsoft.ML.IDataView * string * bool * Nullable<int> * int -> System.Collections.Immutable.ImmutableArray<Microsoft.ML.Data.MulticlassClassificationMetricsStatistics> (requires 'Model : null)
<Extension()>
Public Function PermutationFeatureImportance(Of TModel As Class) (catalog As MulticlassClassificationCatalog, predictionTransformer As ISingleFeaturePredictionTransformer(Of TModel), 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 ImmutableArray(Of MulticlassClassificationMetricsStatistics)

Parâmetros de tipo

TModel

Parâmetros

catalog
MulticlassClassificationCatalog

O catálogo de classificação multiclasse.

predictionTransformer
ISingleFeaturePredictionTransformer<TModel>

O modelo no qual avaliar a importância do recurso.

data
IDataView

O conjunto de dados de avaliação.

labelColumnName
String

Nome da coluna de rótulo. Os dados da coluna devem ser KeyDataViewType.

useFeatureWeightFilter
Boolean

Use o peso dos recursos para pré-filtrar recursos.

numberOfExamplesToUse
Nullable<Int32>

Limite o número de exemplos a serem avaliados. significa que até ~2 exemplos de bln serão usados.

permutationCount
Int32

O número de permutações a serem executadas.

Retornos

Matriz de 'contribuições' por recurso para a pontuação.

Exemplos

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

namespace Samples.Dynamic.Trainers.MulticlassClassification
{
    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.Conversion.MapValueToKey("Label"))
                .Append(mlContext.Transforms.NormalizeMinMax("Features"))
                .Append(mlContext.MulticlassClassification.Trainers
                .SdcaMaximumEntropy());

            // 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.MulticlassClassification
                .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
            // microaccuracy.
            var sortedIndices = permutationMetrics
                .Select((metrics, index) => new { index, metrics.MicroAccuracy })
                .OrderByDescending(feature => Math.Abs(feature.MicroAccuracy.Mean))
                .Select(feature => feature.index);

            Console.WriteLine("Feature\tChange in MicroAccuracy\t95% Confidence in "
                + "the Mean Change in MicroAccuracy");

            var microAccuracy = permutationMetrics.Select(x => x.MicroAccuracy)
                .ToArray();

            foreach (int i in sortedIndices)
            {
                Console.WriteLine("{0}\t{1:G4}\t{2:G4}",
                    featureColumns[i],
                    microAccuracy[i].Mean,
                    1.96 * microAccuracy[i].StandardError);
            }

            // Expected output:
            //Feature     Change in MicroAccuracy  95% Confidence in the Mean Change in MicroAccuracy
            //Feature2     -0.1395                 0.0006567
            //Feature1     -0.05367                0.0006908
        }

        private class Data
        {
            public float 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);
            var max = bias + 4.5 * weight1 + 4.5 * weight2 + 0.5;
            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);

                if (value < max / 3)
                    data.Label = 0;
                else if (value < 2 * max / 3)
                    data.Label = 1;
                else
                    data.Label = 2;
                yield return data;
            }
        }
    }
}

Comentários

A PFI (importância do recurso de permutação) é uma técnica para determinar a importância global dos recursos em um modelo de aprendizado de máquina treinado. PFI é uma técnica simples, mas poderosa, motivada por Breiman em seu artigo da Floresta Aleatória, seção 10 (Breiman. "Florestas aleatórias". Machine Learning, 2001.) A vantagem do método PFI é que ele é agnóstico de modelo , ele funciona com qualquer modelo que pode ser avaliado - e pode usar qualquer conjunto de dados, não apenas o conjunto de treinamento, para calcular métricas de importância do recurso.

O PFI funciona usando um conjunto de dados rotulado, escolhendo um recurso e permutando os valores desse recurso em todos os exemplos, de modo que cada exemplo agora tenha um valor aleatório para o recurso e os valores originais para todos os outros recursos. A métrica de avaliação (por exemplo, microatidão) é calculada para esse conjunto de dados modificado e a alteração na métrica de avaliação do conjunto de dados original é calculada. Quanto maior a alteração na métrica de avaliação, mais importante será o recurso para o modelo. O PFI funciona executando essa análise de permutação em todos os recursos de um modelo, um após o outro.

Nesta implementação, o PFI calcula a alteração em todas as métricas de avaliação de classificação de várias classes possíveis para cada recurso e um ImmutableArray dos MulticlassClassificationMetrics objetos é retornado. Confira o exemplo abaixo para obter um exemplo de como trabalhar com esses resultados para analisar a importância do recurso de um modelo.

Aplica-se a

PermutationFeatureImportance<TModel>(RegressionCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Regressão.

public static System.Collections.Immutable.ImmutableArray<Microsoft.ML.Data.RegressionMetricsStatistics> PermutationFeatureImportance<TModel> (this Microsoft.ML.RegressionCatalog catalog, Microsoft.ML.ISingleFeaturePredictionTransformer<TModel> predictionTransformer, Microsoft.ML.IDataView data, string labelColumnName = "Label", bool useFeatureWeightFilter = false, int? numberOfExamplesToUse = default, int permutationCount = 1) where TModel : class;
static member PermutationFeatureImportance : Microsoft.ML.RegressionCatalog * Microsoft.ML.ISingleFeaturePredictionTransformer<'Model (requires 'Model : null)> * Microsoft.ML.IDataView * string * bool * Nullable<int> * int -> System.Collections.Immutable.ImmutableArray<Microsoft.ML.Data.RegressionMetricsStatistics> (requires 'Model : null)
<Extension()>
Public Function PermutationFeatureImportance(Of TModel As Class) (catalog As RegressionCatalog, predictionTransformer As ISingleFeaturePredictionTransformer(Of TModel), 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 ImmutableArray(Of RegressionMetricsStatistics)

Parâmetros de tipo

TModel

Parâmetros

catalog
RegressionCatalog

O catálogo de regressão.

predictionTransformer
ISingleFeaturePredictionTransformer<TModel>

O modelo no qual avaliar a importância do recurso.

data
IDataView

O conjunto de dados de avaliação.

labelColumnName
String

Nome da coluna de rótulo. Os dados da coluna devem ser Single.

useFeatureWeightFilter
Boolean

Use o peso dos recursos para pré-filtrar recursos.

numberOfExamplesToUse
Nullable<Int32>

Limite o número de exemplos a serem avaliados. significa que até ~2 exemplos de bln serão usados.

permutationCount
Int32

O número de permutações a serem executadas.

Retornos

Matriz de 'contribuições' por recurso para a pontuação.

Exemplos

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

namespace Samples.Dynamic.Trainers.Regression
{
    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.Regression.Trainers.Ols());

            // 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.Regression
                .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 RMSE.
            var sortedIndices = permutationMetrics
                .Select((metrics, index) => new
                {
                    index,
                    metrics.RootMeanSquaredError
                })

                .OrderByDescending(feature => Math.Abs(
                    feature.RootMeanSquaredError.Mean))

                .Select(feature => feature.index);

            Console.WriteLine("Feature\tModel Weight\tChange in RMSE\t95%" +
                "Confidence in the Mean Change in RMSE");

            var rmse = permutationMetrics.Select(x => x.RootMeanSquaredError)
                .ToArray();

            foreach (int i in sortedIndices)
            {
                Console.WriteLine("{0}\t{1:0.00}\t{2:G4}\t{3:G4}",
                    featureColumns[i],
                    linearPredictor.Model.Weights[i],
                    rmse[i].Mean,
                    1.96 * rmse[i].StandardError);
            }

            // Expected output:
            //  Feature    Model Weight Change in RMSE  95% Confidence in the Mean Change in RMSE
            //  Feature2        9.00        4.009       0.008304
            //  Feature1        4.48        1.901       0.003351
        }

        private class Data
        {
            public float 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.
                data.Label = (float)(bias + weight1 * data.Feature1 + weight2 *
                    data.Feature2 + rng.NextDouble() - 0.5);
                yield return data;
            }
        }
    }
}

Comentários

A PFI (importância do recurso de permutação) é uma técnica para determinar a importância global dos recursos em um modelo de aprendizado de máquina treinado. PFI é uma técnica simples, mas poderosa, motivada por Breiman em seu artigo da Floresta Aleatória, seção 10 (Breiman. "Florestas aleatórias". Machine Learning, 2001.) A vantagem do método PFI é que ele é agnóstico de modelo , ele funciona com qualquer modelo que pode ser avaliado - e pode usar qualquer conjunto de dados, não apenas o conjunto de treinamento, para calcular métricas de importância do recurso.

O PFI funciona usando um conjunto de dados rotulado, escolhendo um recurso e permutando os valores desse recurso em todos os exemplos, de modo que cada exemplo agora tenha um valor aleatório para o recurso e os valores originais para todos os outros recursos. A métrica de avaliação (por exemplo, R-squared) é calculada para esse conjunto de dados modificado e a alteração na métrica de avaliação do conjunto de dados original é calculada. Quanto maior a alteração na métrica de avaliação, mais importante será o recurso para o modelo. O PFI funciona executando essa análise de permutação em todos os recursos de um modelo, um após o outro.

Nesta implementação, o PFI calcula a alteração em todas as métricas de avaliação de regressão possíveis para cada recurso e um ImmutableArray dos RegressionMetrics objetos é retornado. Confira o exemplo abaixo para obter um exemplo de como trabalhar com esses resultados para analisar a importância do recurso de um modelo.

Aplica-se a

PermutationFeatureImportance<TModel>(RankingCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, String, Boolean, Nullable<Int32>, Int32)

PFI (Importância do Recurso de Permutação) para Classificação.

public static System.Collections.Immutable.ImmutableArray<Microsoft.ML.Data.RankingMetricsStatistics> PermutationFeatureImportance<TModel> (this Microsoft.ML.RankingCatalog catalog, Microsoft.ML.ISingleFeaturePredictionTransformer<TModel> predictionTransformer, Microsoft.ML.IDataView data, string labelColumnName = "Label", string rowGroupColumnName = "GroupId", bool useFeatureWeightFilter = false, int? numberOfExamplesToUse = default, int permutationCount = 1) where TModel : class;
static member PermutationFeatureImportance : Microsoft.ML.RankingCatalog * Microsoft.ML.ISingleFeaturePredictionTransformer<'Model (requires 'Model : null)> * Microsoft.ML.IDataView * string * string * bool * Nullable<int> * int -> System.Collections.Immutable.ImmutableArray<Microsoft.ML.Data.RankingMetricsStatistics> (requires 'Model : null)
<Extension()>
Public Function PermutationFeatureImportance(Of TModel As Class) (catalog As RankingCatalog, predictionTransformer As ISingleFeaturePredictionTransformer(Of TModel), data As IDataView, Optional labelColumnName As String = "Label", Optional rowGroupColumnName As String = "GroupId", Optional useFeatureWeightFilter As Boolean = false, Optional numberOfExamplesToUse As Nullable(Of Integer) = Nothing, Optional permutationCount As Integer = 1) As ImmutableArray(Of RankingMetricsStatistics)

Parâmetros de tipo

TModel

Parâmetros

catalog
RankingCatalog

O catálogo de classificação.

predictionTransformer
ISingleFeaturePredictionTransformer<TModel>

O modelo no qual avaliar a importância do recurso.

data
IDataView

O conjunto de dados de avaliação.

labelColumnName
String

Nome da coluna de rótulo. Os dados da coluna devem ser Single ou KeyDataViewType.

rowGroupColumnName
String

Nome da coluna GroupId

useFeatureWeightFilter
Boolean

Use o peso dos recursos para pré-filtrar recursos.

numberOfExamplesToUse
Nullable<Int32>

Limite o número de exemplos a serem avaliados. significa que até ~2 exemplos de bln serão usados.

permutationCount
Int32

O número de permutações a serem executadas.

Retornos

Matriz de 'contribuições' por recurso para a pontuação.

Exemplos

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

namespace Samples.Dynamic.Trainers.Ranking
{
    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.Conversion.MapValueToKey("Label"))
                    .Append(mlContext.Transforms.Conversion.MapValueToKey(
                        "GroupId"))
                    .Append(mlContext.Transforms.NormalizeMinMax("Features"))
                    .Append(mlContext.Ranking.Trainers.FastTree());

            // 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.Ranking.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 NDCG@1.
            var sortedIndices = permutationMetrics.Select((metrics, index) => new
            {
                index,
                metrics.NormalizedDiscountedCumulativeGains
            })
                .OrderByDescending(feature => Math.Abs(
                    feature.NormalizedDiscountedCumulativeGains[0].Mean))

                .Select(feature => feature.index);

            Console.WriteLine("Feature\tChange in NDCG@1\t95% Confidence in the" +
                "Mean Change in NDCG@1");
            var ndcg = permutationMetrics.Select(
                x => x.NormalizedDiscountedCumulativeGains).ToArray();
            foreach (int i in sortedIndices)
            {
                Console.WriteLine("{0}\t{1:G4}\t{2:G4}",
                    featureColumns[i],
                    ndcg[i][0].Mean,
                    1.96 * ndcg[i][0].StandardError);
            }

            // Expected output:
            //  Feature     Change in NDCG@1    95% Confidence in the Mean Change in NDCG@1
            //  Feature2     -0.2421            0.001748
            //  Feature1     -0.0513            0.001184
        }

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

            public int GroupId { 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,
                int groupSize = 5)
        {
            var rng = new Random(seed);
            var max = bias + 4.5 * weight1 + 4.5 * weight2 + 0.5;
            for (int i = 0; i < nExamples; i++)
            {
                var data = new Data
                {
                    GroupId = i / groupSize,
                    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);
                if (value < max / 3)
                    data.Label = 0;
                else if (value < 2 * max / 3)
                    data.Label = 1;
                else
                    data.Label = 2;
                yield return data;
            }
        }
    }
}

Comentários

A PFI (importância do recurso de permutação) é uma técnica para determinar a importância global dos recursos em um modelo de aprendizado de máquina treinado. PFI é uma técnica simples, mas poderosa, motivada por Breiman em seu artigo da Floresta Aleatória, seção 10 (Breiman. "Florestas aleatórias". Machine Learning, 2001.) A vantagem do método PFI é que ele é agnóstico de modelo , ele funciona com qualquer modelo que pode ser avaliado - e pode usar qualquer conjunto de dados, não apenas o conjunto de treinamento, para calcular métricas de importância do recurso.

O PFI funciona usando um conjunto de dados rotulado, escolhendo um recurso e permutando os valores desse recurso em todos os exemplos, de modo que cada exemplo agora tenha um valor aleatório para o recurso e os valores originais para todos os outros recursos. A métrica de avaliação (por exemplo, NDCG) é calculada para esse conjunto de dados modificado e a alteração na métrica de avaliação do conjunto de dados original é calculada. Quanto maior a alteração na métrica de avaliação, mais importante será o recurso para o modelo. O PFI funciona executando essa análise de permutação em todos os recursos de um modelo, um após o outro.

Nesta implementação, o PFI calcula a alteração em todas as métricas de avaliação de classificação possíveis para cada recurso e um ImmutableArray dos RankingMetrics objetos é retornado. Confira o exemplo abaixo para obter um exemplo de como trabalhar com esses resultados para analisar a importância do recurso de um modelo.

Aplica-se a