ConversionsExtensionsCatalog.MapKeyToVector Method

public static Microsoft.ML.Transforms.KeyToVectorMappingEstimator MapKeyToVector (this Microsoft.ML.TransformsCatalog.ConversionTransforms catalog, Microsoft.ML.InputOutputColumnPair[] columns, bool outputCountVector = false);

static member MapKeyToVector : Microsoft.ML.TransformsCatalog.ConversionTransforms * Microsoft.ML.InputOutputColumnPair[] * bool -> Microsoft.ML.Transforms.KeyToVectorMappingEstimator

<Extension()>
Public Function MapKeyToVector (catalog As TransformsCatalog.ConversionTransforms, columns As InputOutputColumnPair(), Optional outputCountVector As Boolean = false) As KeyToVectorMappingEstimator

Parameters

Returns

Examples

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

namespace Samples.Dynamic
{
    public class MapKeyToVectorMultiColumn
    {
        /// This example demonstrates the use of MapKeyToVector by mapping keys to
        /// floats[] for multiple columns at once. Because the ML.NET KeyType maps
        /// the missing value to zero, counting starts at 1, so the uint values
        /// converted to KeyTypes will appear skewed by one.
        /// See https://github.com/dotnet/machinelearning/blob/main/docs/code/IDataViewTypeSystem.md#key-types
        public static void Example()
        {
            // Create a new ML context, for ML.NET operations. It can be used for
            // exception tracking and logging, as well as the source of randomness.
            var mlContext = new MLContext();

            // Get a small dataset as an IEnumerable.
            var rawData = new[] {
                new DataPoint() { Timeframe = 9, Category = 5 },
                new DataPoint() { Timeframe = 8, Category = 4 },
                new DataPoint() { Timeframe = 8, Category = 4 },
                new DataPoint() { Timeframe = 9, Category = 3 },
                new DataPoint() { Timeframe = 2, Category = 3 },
                new DataPoint() { Timeframe = 3, Category = 5 }
            };

            var data = mlContext.Data.LoadFromEnumerable(rawData);

            // Constructs the ML.net pipeline
            var pipeline = mlContext.Transforms.Conversion.MapKeyToVector(new[]{
                    new InputOutputColumnPair ("TimeframeVector", "Timeframe"),
                    new InputOutputColumnPair ("CategoryVector", "Category")
            });

            // Fits the pipeline to the data.
            IDataView transformedData = pipeline.Fit(data).Transform(data);

            // Getting the resulting data as an IEnumerable.
            // This will contain the newly created columns.
            IEnumerable<TransformedData> features = mlContext.Data.CreateEnumerable<
                TransformedData>(transformedData, reuseRowObject: false);

            Console.WriteLine($" Timeframe           TimeframeVector         " +
                $"Category    CategoryVector");

            foreach (var featureRow in features)
                Console.WriteLine(featureRow.Timeframe + "     " +
                    string.Join(',', featureRow.TimeframeVector) + "   " +
                    featureRow.Category + "      " +
                    string.Join(',', featureRow.CategoryVector));

            // TransformedData obtained post-transformation.
            //
            // Timeframe          TimeframeVector    Category    CategoryVector
            //  10              0,0,0,0,0,0,0,0,0,1       6          0,0,0,0,0
            //  9               0,0,0,0,0,0,0,0,1,0       5          0,0,0,0,1
            //  9               0,0,0,0,0,0,0,0,1,0       5          0,0,0,0,1
            //  10              0,0,0,0,0,0,0,0,0,1       4          0,0,0,1,0
            //  3               0,0,1,0,0,0,0,0,0,0       4          0,0,0,1,0
            //  4               0,0,0,1,0,0,0,0,0,0       6          0,0,0,0,0
        }

        private class DataPoint
        {
            // The maximal value used is 9; but since 0 is reserved for missing
            // value, we set the count to 10.
            [KeyType(10)]
            public uint Timeframe { get; set; }

            [KeyType(6)]
            public uint Category { get; set; }

        }

        private class TransformedData : DataPoint
        {
            public float[] TimeframeVector { get; set; }
            public float[] CategoryVector { get; set; }
        }
    }
}

Remarks

This transform can operate over several columns of keys.

public static Microsoft.ML.Transforms.KeyToVectorMappingEstimator MapKeyToVector (this Microsoft.ML.TransformsCatalog.ConversionTransforms catalog, string outputColumnName, string inputColumnName = default, bool outputCountVector = false);

static member MapKeyToVector : Microsoft.ML.TransformsCatalog.ConversionTransforms * string * string * bool -> Microsoft.ML.Transforms.KeyToVectorMappingEstimator

<Extension()>
Public Function MapKeyToVector (catalog As TransformsCatalog.ConversionTransforms, outputColumnName As String, Optional inputColumnName As String = Nothing, Optional outputCountVector As Boolean = false) As KeyToVectorMappingEstimator

Parameters

Returns

Examples

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

namespace Samples.Dynamic
{
    class MapKeyToVector
    {
        /// This example demonstrates the use of MapKeyToVector by mapping keys to
        /// floats[]. Because the ML.NET KeyType maps the missing value to zero,
        /// counting starts at 1, so the uint values converted to KeyTypes will
        /// appear skewed by one. See https://github.com/dotnet/machinelearning/blob/main/docs/code/IDataViewTypeSystem.md#key-types
        public static void Example()
        {
            // Create a new ML context, for ML.NET operations. It can be used for
            // exception tracking and logging, as well as the source of randomness.
            var mlContext = new MLContext();

            // Get a small dataset as an IEnumerable.
            var rawData = new[] {
                new DataPoint() { Timeframe = 8, PartA=1, PartB=2},
                new DataPoint() { Timeframe = 7, PartA=2, PartB=1},
                new DataPoint() { Timeframe = 8, PartA=3, PartB=2},
                new DataPoint() { Timeframe = 3, PartA=3, PartB=3}
            };

            var data = mlContext.Data.LoadFromEnumerable(rawData);

            // First transform just maps key type to indicator vector. i.e. it's
            // produces vector filled with zeros with size of key cardinality and
            // set 1 to corresponding key's value index in that array. After that we
            // concatenate two columns with single int values into vector of ints.
            // Third transform will create vector of keys, where key type is shared
            // across whole vector. Forth transform output data as count vector and
            // that vector would have size equal to shared key type cardinality and
            // put key counts to corresponding indexes in array. Fifth transform
            // output indicator vector for each key and concatenate them together.
            // Result vector would be size of key cardinality multiplied by size of
            // original vector.
            var pipeline = mlContext.Transforms.Conversion.MapKeyToVector(
                "TimeframeVector", "Timeframe")
                .Append(mlContext.Transforms.Concatenate("Parts", "PartA", "PartB"))
                .Append(mlContext.Transforms.Conversion.MapValueToKey("Parts"))
                .Append(mlContext.Transforms.Conversion.MapKeyToVector(
                    "PartsCount", "Parts", outputCountVector: true))
                .Append(mlContext.Transforms.Conversion.MapKeyToVector(
                    "PartsNoCount", "Parts"));

            // Fits the pipeline to the data.
            IDataView transformedData = pipeline.Fit(data).Transform(data);

            // Getting the resulting data as an IEnumerable.
            // This will contain the newly created columns.
            IEnumerable<TransformedData> features = mlContext.Data.CreateEnumerable<
                TransformedData>(transformedData, reuseRowObject: false);

            Console.WriteLine("Timeframe  TimeframeVector    PartsCount  " +
                "PartsNoCount");

            foreach (var featureRow in features)
                Console.WriteLine(featureRow.Timeframe + "          " +
                    string.Join(',', featureRow.TimeframeVector.Select(x => x)) + "  "
                    + string.Join(',', featureRow.PartsCount.Select(x => x)) +
                    "       " + string.Join(',', featureRow.PartsNoCount.Select(
                    x => x)));

            // Expected output:
            //  Timeframe  TimeframeVector    PartsCount  PartsNoCount
            //  9          0,0,0,0,0,0,0,0,1  1,1,0       1,0,0,0,1,0
            //  8          0,0,0,0,0,0,0,1,0  1,1,0       0,1,0,1,0,0
            //  9          0,0,0,0,0,0,0,0,1  0,1,1       0,0,1,0,1,0
            //  4          0,0,0,1,0,0,0,0,0  0,0,2       0,0,1,0,0,1
        }

        private class DataPoint
        {
            [KeyType(9)]
            public uint Timeframe { get; set; }
            public int PartA { get; set; }
            public int PartB { get; set; }

        }

        private class TransformedData : DataPoint
        {
            public float[] TimeframeVector { get; set; }
            public float[] PartsCount { get; set; }
            public float[] PartsNoCount { get; set; }
        }
    }
}