StandardTrainersCatalog.PairwiseCoupling<TModel> Methode

Definition

Namespace:

Microsoft.ML

Assembly:

Microsoft.ML.StandardTrainers.dll

Paket:

Microsoft.ML v3.0.1

Erstellen Sie ein PairwiseCouplingTrainer, das ein multiklassiges Ziel mithilfe der Kopplungsstrategie mit der binärklassigen Klassifikations-Stimator prognostiziert, die durch binaryEstimator.

public static Microsoft.ML.Trainers.PairwiseCouplingTrainer PairwiseCoupling<TModel> (this Microsoft.ML.MulticlassClassificationCatalog.MulticlassClassificationTrainers catalog, Microsoft.ML.Trainers.ITrainerEstimator<Microsoft.ML.ISingleFeaturePredictionTransformer<TModel>,TModel> binaryEstimator, string labelColumnName = "Label", bool imputeMissingLabelsAsNegative = false, Microsoft.ML.IEstimator<Microsoft.ML.ISingleFeaturePredictionTransformer<Microsoft.ML.Calibrators.ICalibrator>> calibrator = default, int maximumCalibrationExampleCount = 1000000000) where TModel : class;

static member PairwiseCoupling : Microsoft.ML.MulticlassClassificationCatalog.MulticlassClassificationTrainers * Microsoft.ML.Trainers.ITrainerEstimator<Microsoft.ML.ISingleFeaturePredictionTransformer<'Model>, 'Model (requires 'Model : null)> * string * bool * Microsoft.ML.IEstimator<Microsoft.ML.ISingleFeaturePredictionTransformer<Microsoft.ML.Calibrators.ICalibrator>> * int -> Microsoft.ML.Trainers.PairwiseCouplingTrainer (requires 'Model : null)

<Extension()>
Public Function PairwiseCoupling(Of TModel As Class) (catalog As MulticlassClassificationCatalog.MulticlassClassificationTrainers, binaryEstimator As ITrainerEstimator(Of ISingleFeaturePredictionTransformer(Of TModel), TModel), Optional labelColumnName As String = "Label", Optional imputeMissingLabelsAsNegative As Boolean = false, Optional calibrator As IEstimator(Of ISingleFeaturePredictionTransformer(Of ICalibrator)) = Nothing, Optional maximumCalibrationExampleCount As Integer = 1000000000) As PairwiseCouplingTrainer

Typparameter

TModel

Der Typ des Modells. Dieser Typparameter wird in der Regel automatisch von binaryEstimator.

Parameter

catalog

MulticlassClassificationCatalog.MulticlassClassificationTrainers

Das Objekt des Katalogkatalogs für mehrklassige Klassifizierungen.

binaryEstimator

ITrainerEstimator<ISingleFeaturePredictionTransformer<TModel>,TModel>

Eine Instanz einer Binärdatei ITrainerEstimator<TTransformer,TModel> , die als Basistrainer verwendet wird.

labelColumnName

String

Der Name der Bezeichnungsspalte.

imputeMissingLabelsAsNegative

Boolean

Ob fehlende Bezeichnungen als negative Bezeichnungen behandelt werden sollen, anstatt sie fehlen zu lassen.

calibrator

IEstimator<ISingleFeaturePredictionTransformer<ICalibrator>>

Der Kalibrierer. Wenn ein Kalibrieror nicht explizit bereitgestellt wird, wird er standardmäßig auf Microsoft.ML.Calibrators.PlattCalibratorTrainer

maximumCalibrationExampleCount

Int32

Anzahl der Instanzen zum Trainieren des Kalibrierors.

Gibt zurück

PairwiseCouplingTrainer

Beispiele

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

namespace Samples.Dynamic.Trainers.MulticlassClassification
{
    public static class PairwiseCoupling
    {
        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. Setting the seed to a fixed number
            // in this example to make outputs deterministic.
            var mlContext = new MLContext(seed: 0);

            // Create a list of training data points.
            var dataPoints = GenerateRandomDataPoints(1000);

            // Convert the list of data points to an IDataView object, which is
            // consumable by ML.NET API.
            var trainingData = mlContext.Data.LoadFromEnumerable(dataPoints);

            // Define the trainer.
            var pipeline =
                // Convert the string labels into key types.
                mlContext.Transforms.Conversion.MapValueToKey("Label")
                // Apply PairwiseCoupling multiclass meta trainer on top of
                // binary trainer.
                .Append(mlContext.MulticlassClassification.Trainers
                .PairwiseCoupling(
                mlContext.BinaryClassification.Trainers.SdcaLogisticRegression()));

            // Train the model.
            var model = pipeline.Fit(trainingData);

            // Create testing data. Use different random seed to make it different
            // from training data.
            var testData = mlContext.Data
                .LoadFromEnumerable(GenerateRandomDataPoints(500, seed: 123));

            // Run the model on test data set.
            var transformedTestData = model.Transform(testData);

            // Convert IDataView object to a list.
            var predictions = mlContext.Data
                .CreateEnumerable<Prediction>(transformedTestData,
                reuseRowObject: false).ToList();

            // Look at 5 predictions
            foreach (var p in predictions.Take(5))
                Console.WriteLine($"Label: {p.Label}, " +
                    $"Prediction: {p.PredictedLabel}");

            // Expected output:
            //   Label: 1, Prediction: 1
            //   Label: 2, Prediction: 2
            //   Label: 3, Prediction: 2
            //   Label: 2, Prediction: 2
            //   Label: 3, Prediction: 2

            // Evaluate the overall metrics
            var metrics = mlContext.MulticlassClassification
                .Evaluate(transformedTestData);

            PrintMetrics(metrics);

            // Expected output:
            //   Micro Accuracy: 0.90
            //   Macro Accuracy: 0.90
            //   Log Loss: 0.36
            //   Log Loss Reduction: 0.67

            //   Confusion table
            //             ||========================
            //   PREDICTED ||     0 |     1 |     2 | Recall
            //   TRUTH     ||========================
            //           0 ||   150 |     0 |    10 | 0.9375
            //           1 ||     0 |   166 |    11 | 0.9379
            //           2 ||    15 |    15 |   133 | 0.8160
            //             ||========================
            //   Precision ||0.9091 |0.9171 |0.8636 |
        }

        // Generates random uniform doubles in [-0.5, 0.5)
        // range with labels 1, 2 or 3.
        private static IEnumerable<DataPoint> GenerateRandomDataPoints(int count,
            int seed = 0)

        {
            var random = new Random(seed);
            float randomFloat() => (float)(random.NextDouble() - 0.5);
            for (int i = 0; i < count; i++)
            {
                // Generate Labels that are integers 1, 2 or 3
                var label = random.Next(1, 4);
                yield return new DataPoint
                {
                    Label = (uint)label,
                    // Create random features that are correlated with the label.
                    // The feature values are slightly increased by adding a
                    // constant multiple of label.
                    Features = Enumerable.Repeat(label, 20)
                        .Select(x => randomFloat() + label * 0.2f).ToArray()

                };
            }
        }

        // Example with label and 20 feature values. A data set is a collection of
        // such examples.
        private class DataPoint
        {
            public uint Label { get; set; }
            [VectorType(20)]
            public float[] Features { get; set; }
        }

        // Class used to capture predictions.
        private class Prediction
        {
            // Original label.
            public uint Label { get; set; }
            // Predicted label from the trainer.
            public uint PredictedLabel { get; set; }
        }

        // Pretty-print MulticlassClassificationMetrics objects.
        public static void PrintMetrics(MulticlassClassificationMetrics metrics)
        {
            Console.WriteLine($"Micro Accuracy: {metrics.MicroAccuracy:F2}");
            Console.WriteLine($"Macro Accuracy: {metrics.MacroAccuracy:F2}");
            Console.WriteLine($"Log Loss: {metrics.LogLoss:F2}");
            Console.WriteLine(
                $"Log Loss Reduction: {metrics.LogLossReduction:F2}\n");

            Console.WriteLine(metrics.ConfusionMatrix.GetFormattedConfusionTable());
        }
    }
}

Hinweise

In der Strategie "Pairwise Kopplung" (PKPD) wird ein binärer Klassifizierungsalgorithmus verwendet, um einen Klassifizierer für jedes Klassenpaar zu trainieren. Die Vorhersage wird dann ausgeführt, indem diese binären Klassifizierer ausgeführt werden, und das Berechnen einer Bewertung für jede Klasse durch Zählen der Anzahl der binären Klassifizierer, die sie vorhergesagt haben. Die Vorhersage ist die Klasse mit der höchsten Bewertung.