PermutationFeatureImportanceExtensions.PermutationFeatureImportanceNonCalibrated メソッド

定義

名前空間:

Microsoft.ML

アセンブリ:

Microsoft.ML.Transforms.dll

パッケージ:

Microsoft.ML v2.0.0

二項分類の順列特徴の重要度 (PFI)。

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

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

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

パラメーター

catalog

BinaryClassificationCatalog

二項分類カタログ。

model

ITransformer

特徴の重要度を評価するモデル。

data

IDataView

評価データ セット。

labelColumnName

String

ラベルの列名。 列のデータは次の値である Boolean必要があります。

useFeatureWeightFilter

Boolean

特徴の重みを使用して、特徴を事前にフィルター処理します。

numberOfExamplesToUse

Nullable<Int32>

評価する例の数を制限します。 は、最大 2 bln の例が使用されることを意味します。

permutationCount

Int32

実行する順列の数。

戻り値

ImmutableDictionary<String,BinaryClassificationMetricsStatistics>

各機能を、スコアに対する機能ごとの "コントリビューション" にマッピングするディクショナリ。

例

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

注釈

順列特徴の重要度 (PFI) は、トレーニング済みの機械学習モデルにおける特徴のグローバルな重要性を判断する手法です。 PFIは、彼のランダムフォレストの論文でブレイマンによって動機付けられたシンプルでありながら強力な技術です, セクション 10 (ブレイマン. "ランダム フォレスト" Machine Learning,2001.)PFI メソッドの利点は、モデルに依存しないことです。評価できる任意のモデルと連携し、トレーニング セットだけでなく任意のデータセットを使用して、特徴の重要度メトリックを計算できます。

PFI は、ラベル付きデータセットを取得し、特徴を選択し、すべての例でその特徴の値を並べ替えることで機能します。そのため、各例は特徴のランダムな値と、他のすべての特徴の元の値を持つようになります。 その後、この変更されたデータセットに対して評価メトリック (AUC など) が計算され、元のデータセットからの評価メトリックの変更が計算されます。 評価メトリックの変更が大きいほど、特徴はモデルにとってより重要になります。 PFI は、モデルのすべての特徴に対して順列分析を 1 つずつ実行することで機能します。

この実装では、PFI は各機能に対して考えられるすべてのバイナリ分類評価メトリックの変更を計算し、オブジェクトの BinaryClassificationMetrics 1 つがImmutableArray返されます。 これらの結果を使用してモデルの特徴の重要性を分析する例については、以下のサンプルを参照してください。