PermutationFeatureImportanceExtensions.PermutationFeatureImportance Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Surcharges
PermutationFeatureImportance(MulticlassClassificationCatalog, ITransformer, IDataView, String, Boolean, Nullable<Int32>, Int32)
Importance des fonctionnalités de permutation (PFI) pour multiclassification.
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)Paramètres
- catalog
- MulticlassClassificationCatalog
Catalogue de classification multiclasse.
- model
- ITransformer
Modèle sur lequel évaluer l’importance des caractéristiques.
- data
- IDataView
Jeu de données d’évaluation.
- labelColumnName
- String
Nom de colonne d’étiquette. Les données de colonne doivent être KeyDataViewType.
- useFeatureWeightFilter
- Boolean
Utilisez le poids des caractéristiques pour pré-filtrer les fonctionnalités.
Limitez le nombre d’exemples à évaluer. signifie jusqu’à ~2 exemples de bln à partir de 2 seront utilisés.
- permutationCount
- Int32
Nombre de permutations à effectuer.
Retours
Mappage de chaque fonctionnalité à ses « contributions » par fonctionnalité au score.
Exemples
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;
}
}
}
}
Remarques
L’importance des caractéristiques de permutation (PFI) est une technique permettant de déterminer l’importance globale des fonctionnalités dans un modèle Machine Learning entraîné. PFI est une technique simple et puissante motivée par Breiman dans son papier de forêt aléatoire, section 10 (Breiman). « Forêts aléatoires ». Machine Learning, 2001.) L’avantage de la méthode PFI est qu’il s’agit d’un modèle agnostique - il fonctionne avec n’importe quel modèle qui peut être évalué - et il peut utiliser n’importe quel jeu de données, pas seulement le jeu d’entraînement, pour calculer les métriques d’importance des caractéristiques.
PFI fonctionne en prenant un jeu de données étiqueté, en choisissant une fonctionnalité et en permutant les valeurs de cette fonctionnalité dans tous les exemples, afin que chaque exemple ait désormais une valeur aléatoire pour la fonctionnalité et les valeurs d’origine pour toutes les autres fonctionnalités. La métrique d’évaluation (par exemple, la micro-précision) est ensuite calculée pour ce jeu de données modifié, et la modification de la métrique d’évaluation du jeu de données d’origine est calculée. Plus la modification de la métrique d’évaluation est grande, plus la fonctionnalité est importante pour le modèle. PFI fonctionne en effectuant cette analyse de permutation sur toutes les fonctionnalités d’un modèle, l’une après l’autre.
Dans cette implémentation, PFI calcule la modification dans toutes les métriques d’évaluation de classification multiclasse possibles pour chaque fonctionnalité, et un ImmutableArray objet MulticlassClassificationMetrics est retourné. Consultez l’exemple ci-dessous pour obtenir un exemple d’utilisation de ces résultats pour analyser l’importance des caractéristiques d’un modèle.
S’applique à
PermutationFeatureImportance(RegressionCatalog, ITransformer, IDataView, String, Boolean, Nullable<Int32>, Int32)
Importance des fonctionnalités de permutation (PFI) pour la régression.
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)Paramètres
- catalog
- RegressionCatalog
Catalogue de régression.
- model
- ITransformer
Modèle sur lequel évaluer l’importance des caractéristiques.
- data
- IDataView
Jeu de données d’évaluation.
- useFeatureWeightFilter
- Boolean
Utilisez le poids des caractéristiques pour pré-filtrer les fonctionnalités.
Limitez le nombre d’exemples à évaluer. signifie jusqu’à ~2 exemples de bln à partir de 2 seront utilisés.
- permutationCount
- Int32
Nombre de permutations à effectuer.
Retours
Mappage de chaque fonctionnalité à ses « contributions » par fonctionnalité au score.
Exemples
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;
}
}
}
}
Remarques
L’importance des caractéristiques de permutation (PFI) est une technique permettant de déterminer l’importance globale des fonctionnalités dans un modèle Machine Learning entraîné. PFI est une technique simple et puissante motivée par Breiman dans son papier de forêt aléatoire, section 10 (Breiman). « Forêts aléatoires ». Machine Learning, 2001.) L’avantage de la méthode PFI est qu’il s’agit d’un modèle agnostique - il fonctionne avec n’importe quel modèle qui peut être évalué - et il peut utiliser n’importe quel jeu de données, pas seulement le jeu d’entraînement, pour calculer les métriques d’importance des caractéristiques.
PFI fonctionne en prenant un jeu de données étiqueté, en choisissant une fonctionnalité et en permutant les valeurs de cette fonctionnalité dans tous les exemples, afin que chaque exemple ait désormais une valeur aléatoire pour la fonctionnalité et les valeurs d’origine pour toutes les autres fonctionnalités. La métrique d’évaluation (par exemple, R-squared) est ensuite calculée pour ce jeu de données modifié, et la modification de la métrique d’évaluation du jeu de données d’origine est calculée. Plus la modification de la métrique d’évaluation est grande, plus la fonctionnalité est importante pour le modèle. PFI fonctionne en effectuant cette analyse de permutation sur toutes les fonctionnalités d’un modèle, l’une après l’autre.
Dans cette implémentation, PFI calcule la modification dans toutes les métriques d’évaluation de régression possibles pour chaque fonctionnalité, et un ImmutableArray objet RegressionMetrics est retourné. Consultez l’exemple ci-dessous pour obtenir un exemple d’utilisation de ces résultats pour analyser l’importance des caractéristiques d’un modèle.
S’applique à
PermutationFeatureImportance(RankingCatalog, ITransformer, IDataView, String, String, Boolean, Nullable<Int32>, Int32)
Importance des fonctionnalités de permutation (PFI) pour le classement.
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)Paramètres
- catalog
- RankingCatalog
Catalogue de classement.
- model
- ITransformer
Modèle sur lequel évaluer l’importance des caractéristiques.
- data
- IDataView
Jeu de données d’évaluation.
- labelColumnName
- String
Nom de colonne d’étiquette. Les données de colonne doivent être Single ou KeyDataViewType.
- rowGroupColumnName
- String
Nom de colonne GroupId
- useFeatureWeightFilter
- Boolean
Utilisez le poids des caractéristiques pour pré-filtrer les fonctionnalités.
Limitez le nombre d’exemples à évaluer. signifie jusqu’à ~2 exemples de bln à partir de 2 seront utilisés.
- permutationCount
- Int32
Nombre de permutations à effectuer.
Retours
Mappage de chaque fonctionnalité à ses « contributions » par fonctionnalité au score.
Exemples
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;
}
}
}
}
Remarques
L’importance des caractéristiques de permutation (PFI) est une technique permettant de déterminer l’importance globale des fonctionnalités dans un modèle Machine Learning entraîné. PFI est une technique simple et puissante motivée par Breiman dans son papier de forêt aléatoire, section 10 (Breiman). « Forêts aléatoires ». Machine Learning, 2001.) L’avantage de la méthode PFI est qu’il s’agit d’un modèle agnostique - il fonctionne avec n’importe quel modèle qui peut être évalué - et il peut utiliser n’importe quel jeu de données, pas seulement le jeu d’entraînement, pour calculer les métriques d’importance des caractéristiques.
PFI fonctionne en prenant un jeu de données étiqueté, en choisissant une fonctionnalité et en permutant les valeurs de cette fonctionnalité dans tous les exemples, afin que chaque exemple ait désormais une valeur aléatoire pour la fonctionnalité et les valeurs d’origine pour toutes les autres fonctionnalités. La métrique d’évaluation (par exemple, NDCG) est ensuite calculée pour ce jeu de données modifié, et la modification de la métrique d’évaluation du jeu de données d’origine est calculée. Plus la modification de la métrique d’évaluation est grande, plus la fonctionnalité est importante pour le modèle. PFI fonctionne en effectuant cette analyse de permutation sur toutes les fonctionnalités d’un modèle, l’une après l’autre.
Dans cette implémentation, PFI calcule la modification dans toutes les métriques d’évaluation de classement possibles pour chaque fonctionnalité et un ImmutableArray objet RankingMetrics est retourné. Consultez l’exemple ci-dessous pour obtenir un exemple d’utilisation de ces résultats pour analyser l’importance des caractéristiques d’un modèle.
S’applique à
PermutationFeatureImportance<TModel>(BinaryClassificationCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)
Importance des fonctionnalités de permutation (PFI) pour la classification binaire.
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)Paramètres de type
- TModel
Paramètres
- catalog
- BinaryClassificationCatalog
Catalogue de classification binaire.
- predictionTransformer
- ISingleFeaturePredictionTransformer<TModel>
Modèle sur lequel évaluer l’importance des caractéristiques.
- data
- IDataView
Jeu de données d’évaluation.
- useFeatureWeightFilter
- Boolean
Utilisez le poids des caractéristiques pour pré-filtrer les fonctionnalités.
Limitez le nombre d’exemples à évaluer. signifie jusqu’à ~2 exemples de bln à partir de 2 seront utilisés.
- permutationCount
- Int32
Nombre de permutations à effectuer.
Retours
Tableau de « contributions » par fonctionnalité au score.
Exemples
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));
}
}
Remarques
L’importance des caractéristiques de permutation (PFI) est une technique permettant de déterminer l’importance globale des fonctionnalités dans un modèle Machine Learning entraîné. PFI est une technique simple et puissante motivée par Breiman dans son papier de forêt aléatoire, section 10 (Breiman). « Forêts aléatoires ». Machine Learning, 2001.) L’avantage de la méthode PFI est qu’il s’agit d’un modèle agnostique - il fonctionne avec n’importe quel modèle qui peut être évalué - et il peut utiliser n’importe quel jeu de données, pas seulement le jeu d’entraînement, pour calculer les métriques d’importance des caractéristiques.
PFI fonctionne en prenant un jeu de données étiqueté, en choisissant une fonctionnalité et en permutant les valeurs de cette fonctionnalité dans tous les exemples, afin que chaque exemple ait désormais une valeur aléatoire pour la fonctionnalité et les valeurs d’origine pour toutes les autres fonctionnalités. La métrique d’évaluation (par exemple, AUC) est ensuite calculée pour ce jeu de données modifié, et la modification de la métrique d’évaluation du jeu de données d’origine est calculée. Plus la modification de la métrique d’évaluation est grande, plus la fonctionnalité est importante pour le modèle. PFI fonctionne en effectuant cette analyse de permutation sur toutes les fonctionnalités d’un modèle, l’une après l’autre.
Dans cette implémentation, PFI calcule la modification dans toutes les métriques d’évaluation de classification binaire possibles pour chaque fonctionnalité et un ImmutableArray objet BinaryClassificationMetrics est retourné. Consultez l’exemple ci-dessous pour obtenir un exemple d’utilisation de ces résultats pour analyser l’importance des caractéristiques d’un modèle.
S’applique à
PermutationFeatureImportance<TModel>(MulticlassClassificationCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)
Permutation Feature Importance (PFI) pour Multiclassification.
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)Paramètres de type
- TModel
Paramètres
- catalog
- MulticlassClassificationCatalog
Catalogue de classification multiclasse.
- predictionTransformer
- ISingleFeaturePredictionTransformer<TModel>
Modèle sur lequel évaluer l’importance des caractéristiques.
- data
- IDataView
Jeu de données d’évaluation.
- labelColumnName
- String
Nom de colonne d’étiquette. Les données de colonne doivent être KeyDataViewType.
- useFeatureWeightFilter
- Boolean
Utilisez le poids des caractéristiques pour pré-filtrer les fonctionnalités.
Limitez le nombre d’exemples à évaluer. signifie jusqu’à ~2 exemples bln de sera utilisé.
- permutationCount
- Int32
Nombre de permutations à effectuer.
Retours
Tableau de « contributions » par fonctionnalité au score.
Exemples
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;
}
}
}
}
Remarques
L’importance des caractéristiques de permutation (PFI) est une technique permettant de déterminer l’importance globale des fonctionnalités dans un modèle Machine Learning entraîné. PFI est une technique simple mais puissante motivée par Breiman dans son papier de forêt aléatoire, section 10 (Breiman. « Forêts aléatoires ». Machine Learning, 2001.) L’avantage de la méthode PFI est qu’il est indépendant du modèle - il fonctionne avec n’importe quel modèle qui peut être évalué - et il peut utiliser n’importe quel jeu de données, pas seulement le jeu d’entraînement, pour calculer les métriques d’importance des caractéristiques.
PFI fonctionne en prenant un jeu de données étiqueté, en choisissant une fonctionnalité et en permutant les valeurs de cette fonctionnalité dans tous les exemples, afin que chaque exemple ait désormais une valeur aléatoire pour la fonctionnalité et les valeurs d’origine pour toutes les autres fonctionnalités. La métrique d’évaluation (par exemple, la micro-précision) est ensuite calculée pour ce jeu de données modifié, et la modification de la métrique d’évaluation du jeu de données d’origine est calculée. Plus la modification de la métrique d’évaluation est importante, plus la fonctionnalité est importante pour le modèle. PFI fonctionne en effectuant cette analyse de permutation sur toutes les fonctionnalités d’un modèle, l’une après l’autre.
Dans cette implémentation, PFI calcule la modification de toutes les métriques d’évaluation de classification multiclasse possibles pour chaque fonctionnalité, et un ImmutableArray objet MulticlassClassificationMetrics est retourné. Consultez l’exemple ci-dessous pour obtenir un exemple d’utilisation de ces résultats pour analyser l’importance des caractéristiques d’un modèle.
S’applique à
PermutationFeatureImportance<TModel>(RegressionCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)
Permutation Feature Importance (PFI) pour la régression.
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)Paramètres de type
- TModel
Paramètres
- catalog
- RegressionCatalog
Catalogue de régression.
- predictionTransformer
- ISingleFeaturePredictionTransformer<TModel>
Modèle sur lequel évaluer l’importance des caractéristiques.
- data
- IDataView
Jeu de données d’évaluation.
- useFeatureWeightFilter
- Boolean
Utilisez le poids des caractéristiques pour préfiltrer les fonctionnalités.
Limitez le nombre d’exemples à évaluer. signifie jusqu’à ~2 exemples bln de sera utilisé.
- permutationCount
- Int32
Nombre de permutations à effectuer.
Retours
Tableau de « contributions » par fonctionnalité au score.
Exemples
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;
}
}
}
}
Remarques
L’importance des caractéristiques de permutation (PFI) est une technique permettant de déterminer l’importance globale des fonctionnalités dans un modèle Machine Learning entraîné. PFI est une technique simple mais puissante motivée par Breiman dans son papier de forêt aléatoire, section 10 (Breiman. « Forêts aléatoires ». Machine Learning, 2001.) L’avantage de la méthode PFI est qu’il est indépendant du modèle - il fonctionne avec n’importe quel modèle qui peut être évalué - et il peut utiliser n’importe quel jeu de données, pas seulement le jeu d’entraînement, pour calculer les métriques d’importance des caractéristiques.
PFI fonctionne en prenant un jeu de données étiqueté, en choisissant une fonctionnalité et en permutant les valeurs de cette fonctionnalité dans tous les exemples, afin que chaque exemple ait désormais une valeur aléatoire pour la fonctionnalité et les valeurs d’origine pour toutes les autres fonctionnalités. La métrique d’évaluation (par exemple, R-squared) est ensuite calculée pour ce jeu de données modifié, et la modification de la métrique d’évaluation du jeu de données d’origine est calculée. Plus la modification de la métrique d’évaluation est importante, plus la fonctionnalité est importante pour le modèle. PFI fonctionne en effectuant cette analyse de permutation sur toutes les fonctionnalités d’un modèle, l’une après l’autre.
Dans cette implémentation, PFI calcule la modification dans toutes les métriques d’évaluation de régression possibles pour chaque fonctionnalité, et un ImmutableArray objet RegressionMetrics est retourné. Consultez l’exemple ci-dessous pour obtenir un exemple d’utilisation de ces résultats pour analyser l’importance des caractéristiques d’un modèle.
S’applique à
PermutationFeatureImportance<TModel>(RankingCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, String, Boolean, Nullable<Int32>, Int32)
Importance des caractéristiques de permutation (PFI) pour le classement.
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)Paramètres de type
- TModel
Paramètres
- catalog
- RankingCatalog
Catalogue de classement.
- predictionTransformer
- ISingleFeaturePredictionTransformer<TModel>
Modèle sur lequel évaluer l’importance des caractéristiques.
- data
- IDataView
Jeu de données d’évaluation.
- labelColumnName
- String
Nom de colonne d’étiquette. Les données de colonne doivent être Single ou KeyDataViewType.
- rowGroupColumnName
- String
Nom de colonne GroupId
- useFeatureWeightFilter
- Boolean
Utilisez le poids des caractéristiques pour préfiltrer les fonctionnalités.
Limitez le nombre d’exemples à évaluer. signifie jusqu’à ~2 exemples bln de sera utilisé.
- permutationCount
- Int32
Nombre de permutations à effectuer.
Retours
Tableau de « contributions » par fonctionnalité au score.
Exemples
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;
}
}
}
}
Remarques
L’importance des caractéristiques de permutation (PFI) est une technique permettant de déterminer l’importance globale des fonctionnalités dans un modèle Machine Learning entraîné. PFI est une technique simple mais puissante motivée par Breiman dans son papier de forêt aléatoire, section 10 (Breiman. « Forêts aléatoires ». Machine Learning, 2001.) L’avantage de la méthode PFI est qu’il est indépendant du modèle - il fonctionne avec n’importe quel modèle qui peut être évalué - et il peut utiliser n’importe quel jeu de données, pas seulement le jeu d’entraînement, pour calculer les métriques d’importance des caractéristiques.
PFI fonctionne en prenant un jeu de données étiqueté, en choisissant une fonctionnalité et en permutant les valeurs de cette fonctionnalité dans tous les exemples, afin que chaque exemple ait désormais une valeur aléatoire pour la fonctionnalité et les valeurs d’origine pour toutes les autres fonctionnalités. La métrique d’évaluation (par exemple, NDCG) est ensuite calculée pour ce jeu de données modifié, et la modification de la métrique d’évaluation du jeu de données d’origine est calculée. Plus la modification de la métrique d’évaluation est importante, plus la fonctionnalité est importante pour le modèle. PFI fonctionne en effectuant cette analyse de permutation sur toutes les fonctionnalités d’un modèle, l’une après l’autre.
Dans cette implémentation, PFI calcule la modification de toutes les métriques d’évaluation de classement possibles pour chaque fonctionnalité, et un ImmutableArray objet RankingMetrics est retourné. Consultez l’exemple ci-dessous pour obtenir un exemple d’utilisation de ces résultats pour analyser l’importance des caractéristiques d’un modèle.