PermutationFeatureImportanceExtensions.PermutationFeatureImportance Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Überlädt
PermutationFeatureImportance(MulticlassClassificationCatalog, ITransformer, IDataView, String, Boolean, Nullable<Int32>, Int32)
Permutation Feature Importance (PFI) für MulticlassClassification.
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)Parameter
- catalog
- MulticlassClassificationCatalog
Der Katalog der mehrklassigen Klassifizierung.
- model
- ITransformer
Das Modell, auf dem die Feature-Wichtigkeit ausgewertet werden soll.
- data
- IDataView
Der Auswertungsdatensatz.
- labelColumnName
- String
Bezeichnungsspaltenname. Die Spaltendaten müssen sein KeyDataViewType.
- useFeatureWeightFilter
- Boolean
Verwenden Sie features weight to pre-filter features.
Beschränken Sie die Anzahl der Beispiele, die ausgewertet werden sollen. bedeutet bis zu 2 bln Beispiele von werden verwendet.
- permutationCount
- Int32
Die Anzahl der auszuführenden Permutationen.
Gibt zurück
Wörterbuchzuordnung jedes Features zu seinen "Beiträgen" pro Feature zur Bewertung.
Beispiele
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;
}
}
}
}
Hinweise
Permutation feature importance (PFI) ist eine Technik, um die globale Bedeutung von Features in einem trainierten Machine Learning-Modell zu bestimmen. PFI ist eine einfache, aber leistungsstarke Technik, die von Breiman in seinem Zufallswaldpapier, Abschnitt 10 (Breiman) motiviert wurde. "Zufällige Wälder." Machine Learning, 2001.) Der Vorteil der PFI-Methode besteht darin, dass es modellagnostisch ist - es funktioniert mit jedem Modell, das ausgewertet werden kann - und es kann jedes Dataset verwenden, nicht nur den Schulungssatz, um Feature-Wichtigkeitsmetriken zu berechnen.
PFI funktioniert, indem ein beschriftetes Dataset verwendet wird, ein Feature auswählen und die Werte für dieses Feature in allen Beispielen per Stummschaltung ändern, sodass jedes Beispiel jetzt einen Zufälligen Wert für das Feature und die ursprünglichen Werte für alle anderen Features aufweist. Die Auswertungsmetrik (z. B. Mikrogenauigkeit) wird dann für dieses geänderte Dataset berechnet, und die Änderung der Auswertungsmetrik aus dem ursprünglichen Dataset wird berechnet. Je größer die Änderung der Auswertungsmetrik ist, desto wichtiger ist das Feature für das Modell. PFI funktioniert, indem diese Permutationsanalyse über alle Features eines Modells hinweg ausgeführt wird, und zwar nacheinander.
In dieser Implementierung berechnet PFI die Änderung aller möglichen Klassifizierungsbewertungsmetriken für jedes Feature und eine ImmutableArray von MulticlassClassificationMetrics Objekten wird zurückgegeben. Sehen Sie sich das folgende Beispiel an, um mit diesen Ergebnissen zu arbeiten, um die Feature-Wichtigkeit eines Modells zu analysieren.
Gilt für:
PermutationFeatureImportance(RegressionCatalog, ITransformer, IDataView, String, Boolean, Nullable<Int32>, Int32)
Permutation Feature Importance (PFI) für Regression.
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)Parameter
- catalog
- RegressionCatalog
Der Regressionskatalog.
- model
- ITransformer
Das Modell, auf dem die Feature-Wichtigkeit ausgewertet werden soll.
- data
- IDataView
Der Auswertungsdatensatz.
- useFeatureWeightFilter
- Boolean
Verwenden Sie features weight to pre-filter features.
Beschränken Sie die Anzahl der Beispiele, die ausgewertet werden sollen. bedeutet bis zu 2 bln Beispiele von werden verwendet.
- permutationCount
- Int32
Die Anzahl der auszuführenden Permutationen.
Gibt zurück
Wörterbuchzuordnung jedes Features zu seinen "Beiträgen" pro Feature zur Bewertung.
Beispiele
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;
}
}
}
}
Hinweise
Permutation feature importance (PFI) ist eine Technik, um die globale Bedeutung von Features in einem trainierten Machine Learning-Modell zu bestimmen. PFI ist eine einfache, aber leistungsstarke Technik, die von Breiman in seinem Zufallswaldpapier, Abschnitt 10 (Breiman) motiviert wurde. "Zufällige Wälder." Machine Learning, 2001.) Der Vorteil der PFI-Methode besteht darin, dass es modellagnostisch ist - es funktioniert mit jedem Modell, das ausgewertet werden kann - und es kann jedes Dataset verwenden, nicht nur den Schulungssatz, um Feature-Wichtigkeitsmetriken zu berechnen.
PFI funktioniert, indem ein beschriftetes Dataset verwendet wird, ein Feature auswählen und die Werte für dieses Feature in allen Beispielen per Stummschaltung ändern, sodass jedes Beispiel jetzt einen Zufälligen Wert für das Feature und die ursprünglichen Werte für alle anderen Features aufweist. Die Auswertungsmetrik (z. B. R-Quadratd) wird dann für dieses geänderte Dataset berechnet, und die Änderung der Auswertungsmetrik aus dem ursprünglichen Dataset wird berechnet. Je größer die Änderung der Auswertungsmetrik ist, desto wichtiger ist das Feature für das Modell. PFI funktioniert, indem diese Permutationsanalyse über alle Features eines Modells hinweg ausgeführt wird, und zwar nacheinander.
In dieser Implementierung berechnet PFI die Änderung aller möglichen Regressionsauswertungsmetriken für jedes Feature, und ein ImmutableArray Objekt RegressionMetrics wird zurückgegeben. Sehen Sie sich das folgende Beispiel an, um mit diesen Ergebnissen zu arbeiten, um die Feature-Wichtigkeit eines Modells zu analysieren.
Gilt für:
PermutationFeatureImportance(RankingCatalog, ITransformer, IDataView, String, String, Boolean, Nullable<Int32>, Int32)
Permutation Feature Importance (PFI) für die Bewertung.
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)Parameter
- catalog
- RankingCatalog
Der Bewertungskatalog.
- model
- ITransformer
Das Modell, auf dem die Feature-Wichtigkeit ausgewertet werden soll.
- data
- IDataView
Der Auswertungsdatensatz.
- labelColumnName
- String
Bezeichnungsspaltenname. Die Spaltendaten müssen Single oder KeyDataViewType.
- rowGroupColumnName
- String
GroupId-Spaltenname
- useFeatureWeightFilter
- Boolean
Verwenden Sie features weight to pre-filter features.
Beschränken Sie die Anzahl der Beispiele, die ausgewertet werden sollen. bedeutet bis zu 2 bln Beispiele von werden verwendet.
- permutationCount
- Int32
Die Anzahl der auszuführenden Permutationen.
Gibt zurück
Wörterbuchzuordnung jedes Features zu seinen "Beiträgen" pro Feature zur Bewertung.
Beispiele
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;
}
}
}
}
Hinweise
Permutation feature importance (PFI) ist eine Technik, um die globale Bedeutung von Features in einem trainierten Machine Learning-Modell zu bestimmen. PFI ist eine einfache, aber leistungsstarke Technik, die von Breiman in seinem Zufallswaldpapier, Abschnitt 10 (Breiman) motiviert wurde. "Zufällige Wälder." Machine Learning, 2001.) Der Vorteil der PFI-Methode besteht darin, dass es modellagnostisch ist - es funktioniert mit jedem Modell, das ausgewertet werden kann - und es kann jedes Dataset verwenden, nicht nur den Schulungssatz, um Feature-Wichtigkeitsmetriken zu berechnen.
PFI funktioniert, indem ein beschriftetes Dataset verwendet wird, ein Feature auswählen und die Werte für dieses Feature in allen Beispielen per Stummschaltung ändern, sodass jedes Beispiel jetzt einen Zufälligen Wert für das Feature und die ursprünglichen Werte für alle anderen Features aufweist. Die Auswertungsmetrik (z. B. NDCG) wird dann für dieses geänderte Dataset berechnet, und die Änderung der Auswertungsmetrik aus dem ursprünglichen Dataset wird berechnet. Je größer die Änderung der Auswertungsmetrik ist, desto wichtiger ist das Feature für das Modell. PFI funktioniert, indem diese Permutationsanalyse über alle Features eines Modells hinweg ausgeführt wird, und zwar nacheinander.
In dieser Implementierung berechnet PFI die Änderung aller möglichen Bewertungsmetriken für jedes Feature, und eine ImmutableArray von RankingMetrics Objekten wird zurückgegeben. Sehen Sie sich das folgende Beispiel an, um mit diesen Ergebnissen zu arbeiten, um die Feature-Wichtigkeit eines Modells zu analysieren.
Gilt für:
PermutationFeatureImportance<TModel>(BinaryClassificationCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)
Permutation Feature Importance (PFI) für binäre Klassifizierung.
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)Typparameter
- TModel
Parameter
- catalog
- BinaryClassificationCatalog
Der binärklassifizierungskatalog.
- predictionTransformer
- ISingleFeaturePredictionTransformer<TModel>
Das Modell, auf dem die Feature-Wichtigkeit ausgewertet werden soll.
- data
- IDataView
Der Auswertungsdatensatz.
- useFeatureWeightFilter
- Boolean
Verwenden Sie features weight to pre-filter features.
Beschränken Sie die Anzahl der Beispiele, die ausgewertet werden sollen. bedeutet bis zu 2 bln Beispiele von werden verwendet.
- permutationCount
- Int32
Die Anzahl der auszuführenden Permutationen.
Gibt zurück
Array von "Beiträgen pro Feature" für die Bewertung.
Beispiele
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));
}
}
Hinweise
Permutation feature importance (PFI) ist eine Technik, um die globale Bedeutung von Features in einem trainierten Machine Learning-Modell zu bestimmen. PFI ist eine einfache, aber leistungsstarke Technik, die von Breiman in seinem Zufallswaldpapier, Abschnitt 10 (Breiman) motiviert wurde. "Zufällige Wälder." Machine Learning, 2001.) Der Vorteil der PFI-Methode besteht darin, dass es modellagnostisch ist - es funktioniert mit jedem Modell, das ausgewertet werden kann - und es kann jedes Dataset verwenden, nicht nur den Schulungssatz, um Feature-Wichtigkeitsmetriken zu berechnen.
PFI funktioniert, indem ein beschriftetes Dataset verwendet wird, ein Feature auswählen und die Werte für dieses Feature in allen Beispielen per Stummschaltung ändern, sodass jedes Beispiel jetzt einen Zufälligen Wert für das Feature und die ursprünglichen Werte für alle anderen Features aufweist. Die Auswertungsmetrik (z. B. AUC) wird dann für dieses geänderte Dataset berechnet, und die Änderung der Auswertungsmetrik aus dem ursprünglichen Dataset wird berechnet. Je größer die Änderung der Auswertungsmetrik ist, desto wichtiger ist das Feature für das Modell. PFI funktioniert, indem diese Permutationsanalyse über alle Features eines Modells hinweg ausgeführt wird, und zwar nacheinander.
In dieser Implementierung berechnet PFI die Änderung aller möglichen Binären Klassifizierungsauswertungsmetriken für jedes Feature, und eine ImmutableArray von BinaryClassificationMetrics Objekten wird zurückgegeben. Sehen Sie sich das folgende Beispiel an, um mit diesen Ergebnissen zu arbeiten, um die Feature-Wichtigkeit eines Modells zu analysieren.
Gilt für:
PermutationFeatureImportance<TModel>(MulticlassClassificationCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)
Permutation feature importance (PFI) for 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)Typparameter
- TModel
Parameter
- catalog
- MulticlassClassificationCatalog
Der Katalog der mehrklassigen Klassifizierung.
- predictionTransformer
- ISingleFeaturePredictionTransformer<TModel>
Das Modell, auf dem die Feature-Wichtigkeit ausgewertet werden soll.
- data
- IDataView
Der Auswertungsdatensatz.
- labelColumnName
- String
Bezeichnungsspaltenname. Die Spaltendaten müssen sein KeyDataViewType.
- useFeatureWeightFilter
- Boolean
Verwenden Sie features weight to pre-filter features.
Beschränken Sie die Anzahl der Beispiele, die ausgewertet werden sollen. bedeutet bis zu 2 bln Beispiele von werden verwendet.
- permutationCount
- Int32
Die Anzahl der zu ausführenden Permutationen.
Gibt zurück
Array von "Beiträgen" pro Feature für die Bewertung.
Beispiele
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;
}
}
}
}
Hinweise
Permutation feature importance (PFI) ist eine Technik, um die globale Bedeutung von Features in einem trainierten Maschinellen Lernmodell zu bestimmen. PFI ist eine einfache, aber leistungsstarke Technik, die von Breiman in seinem Random Forest-Papier, Abschnitt 10 (Breiman) motiviert wurde. "Zufällige Wälder." Machine Learning, 2001.) Der Vorteil der PFI-Methode besteht darin, dass es modell agnostisch ist - es funktioniert mit jedem Modell, das ausgewertet werden kann - und es kann jedes Dataset verwenden, nicht nur den Schulungssatz, um Feature-Wichtigkeitsmetriken zu berechnen.
PFI funktioniert, indem Sie ein beschriftetes Dataset verwenden, ein Feature auswählen und die Werte für dieses Feature in allen Beispielen permutieren, sodass jedes Beispiel jetzt einen zufälligen Wert für das Feature und die ursprünglichen Werte für alle anderen Features aufweist. Die Auswertungsmetrik (z. B. Mikrogenauigkeit) wird dann für dieses geänderte Dataset berechnet, und die Änderung der Auswertungsmetrik aus dem ursprünglichen Dataset wird berechnet. Je größer die Änderung der Auswertungsmetrik ist, desto wichtiger ist das Feature für das Modell. PFI funktioniert durch die Ausführung dieser Permutationsanalyse über alle Features eines Modells hinweg, eins nacheinander.
In dieser Implementierung berechnet PFI die Änderung aller möglichen Klassifizierungsbewertungsmetriken für jedes Feature, und eine ImmutableArray von MulticlassClassificationMetrics Objekten wird zurückgegeben. Sehen Sie sich das folgende Beispiel an, um mit diesen Ergebnissen zu arbeiten, um die Bedeutung eines Modells zu analysieren.
Gilt für:
PermutationFeatureImportance<TModel>(RegressionCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, Boolean, Nullable<Int32>, Int32)
Permutation Feature Importance (PFI) for Regression.
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)Typparameter
- TModel
Parameter
- catalog
- RegressionCatalog
Der Regressionskatalog.
- predictionTransformer
- ISingleFeaturePredictionTransformer<TModel>
Das Modell, auf das die Feature-Wichtigkeit ausgewertet werden soll.
- data
- IDataView
Der Auswertungsdatensatz.
- useFeatureWeightFilter
- Boolean
Verwenden Sie Features gewichtung, um Vorfilterfeatures zu filtern.
Beschränken Sie die Anzahl der Beispiele, die ausgewertet werden sollen. bedeutet bis zu 2 bln Beispiele von werden verwendet.
- permutationCount
- Int32
Die Anzahl der zu ausführenden Permutationen.
Gibt zurück
Array von "Beiträgen" pro Feature für die Bewertung.
Beispiele
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;
}
}
}
}
Hinweise
Permutation feature importance (PFI) ist eine Technik, um die globale Bedeutung von Features in einem trainierten Maschinellen Lernmodell zu bestimmen. PFI ist eine einfache, aber leistungsstarke Technik, die von Breiman in seinem Random Forest-Papier, Abschnitt 10 (Breiman) motiviert wurde. "Zufällige Wälder." Machine Learning, 2001.) Der Vorteil der PFI-Methode besteht darin, dass es modell agnostisch ist - es funktioniert mit jedem Modell, das ausgewertet werden kann - und es kann jedes Dataset verwenden, nicht nur den Schulungssatz, um Feature-Wichtigkeitsmetriken zu berechnen.
PFI funktioniert, indem Sie ein beschriftetes Dataset verwenden, ein Feature auswählen und die Werte für dieses Feature in allen Beispielen permutieren, sodass jedes Beispiel jetzt einen zufälligen Wert für das Feature und die ursprünglichen Werte für alle anderen Features aufweist. Die Auswertungsmetrik (z. B. R-quadratd) wird dann für dieses geänderte Dataset berechnet, und die Änderung der Auswertungsmetrik aus dem ursprünglichen Dataset wird berechnet. Je größer die Änderung der Auswertungsmetrik ist, desto wichtiger ist das Feature für das Modell. PFI funktioniert durch die Ausführung dieser Permutationsanalyse über alle Features eines Modells hinweg, eins nacheinander.
In dieser Implementierung berechnet PFI die Änderung aller möglichen Regressionsbewertungsmetriken für jedes Feature, und eine ImmutableArray von RegressionMetrics Objekten wird zurückgegeben. Sehen Sie sich das folgende Beispiel an, um mit diesen Ergebnissen zu arbeiten, um die Bedeutung eines Modells zu analysieren.
Gilt für:
PermutationFeatureImportance<TModel>(RankingCatalog, ISingleFeaturePredictionTransformer<TModel>, IDataView, String, String, Boolean, Nullable<Int32>, Int32)
Permutation Feature Importance (PFI) for Ranking.
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)Typparameter
- TModel
Parameter
- catalog
- RankingCatalog
Der Bewertungskatalog.
- predictionTransformer
- ISingleFeaturePredictionTransformer<TModel>
Das Modell, auf das die Feature-Wichtigkeit ausgewertet werden soll.
- data
- IDataView
Der Auswertungsdatensatz.
- labelColumnName
- String
Bezeichnungsspaltenname. Die Spaltendaten müssen Single oder KeyDataViewType.
- rowGroupColumnName
- String
GroupId-Spaltenname
- useFeatureWeightFilter
- Boolean
Verwenden Sie Features gewichtung, um Vorfilterfeatures zu filtern.
Beschränken Sie die Anzahl der Beispiele, die ausgewertet werden sollen. bedeutet bis zu 2 bln Beispiele von werden verwendet.
- permutationCount
- Int32
Die Anzahl der zu ausführenden Permutationen.
Gibt zurück
Array von "Beiträgen" pro Feature für die Bewertung.
Beispiele
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;
}
}
}
}
Hinweise
Permutation feature importance (PFI) ist eine Technik, um die globale Bedeutung von Features in einem trainierten Maschinellen Lernmodell zu bestimmen. PFI ist eine einfache, aber leistungsstarke Technik, die von Breiman in seinem Random Forest-Papier, Abschnitt 10 (Breiman) motiviert wurde. "Zufällige Wälder." Machine Learning, 2001.) Der Vorteil der PFI-Methode besteht darin, dass es modell agnostisch ist - es funktioniert mit jedem Modell, das ausgewertet werden kann - und es kann jedes Dataset verwenden, nicht nur den Schulungssatz, um Feature-Wichtigkeitsmetriken zu berechnen.
PFI funktioniert, indem Sie ein beschriftetes Dataset verwenden, ein Feature auswählen und die Werte für dieses Feature in allen Beispielen permutieren, sodass jedes Beispiel jetzt einen zufälligen Wert für das Feature und die ursprünglichen Werte für alle anderen Features aufweist. Die Auswertungsmetrik (z. B. NDCG) wird dann für dieses geänderte Dataset berechnet, und die Änderung der Auswertungsmetrik aus dem ursprünglichen Dataset wird berechnet. Je größer die Änderung der Auswertungsmetrik ist, desto wichtiger ist das Feature für das Modell. PFI funktioniert durch die Ausführung dieser Permutationsanalyse über alle Features eines Modells hinweg, eins nacheinander.
In dieser Implementierung berechnet PFI die Änderung aller möglichen Bewertungsmetriken für jedes Feature, und eine ImmutableArray von RankingMetrics Objekten wird zurückgegeben. Sehen Sie sich das folgende Beispiel an, um mit diesen Ergebnissen zu arbeiten, um die Bedeutung eines Modells zu analysieren.