idv and decomposableTrain

Author: Ivan Matantsev

test/Microsoft.ML.Tests/Scenarios/Api/ApiScenariosTests.cs

@@ -17,9 +17,25 @@ public ApiScenariosTests(ITestOutputHelper output) : base(output)
         {
         }
 
+        public const string IrisDataPath = "iris.data";
         public const string SentimentDataPath = "wikipedia-detox-250-line-data.tsv";
         public const string SentimentTestPath = "wikipedia-detox-250-line-test.tsv";
 
+        public class IrisData
+        {
+            public float SepalLength;
+            public float SepalWidth;
+            public float PetalLength;
+            public float PetalWidth;
+            public string Label;
+        }
+
+        public class IrisPrediction
+        {
+            public string PredictedLabel;
+            public float[] Score;
+        }
+
         public class SentimentData
         {
             [ColumnName("Label")]

test/Microsoft.ML.Tests/Scenarios/Api/DecomposableTrainAndPredictcs.cs

@@ -0,0 +1,56 @@
+using Microsoft.ML.Runtime.Api;
+using Microsoft.ML.Runtime.Data;
+using Microsoft.ML.Runtime.Learners;
+using System.Linq;
+using Xunit;
+
+namespace Microsoft.ML.Tests.Scenarios.Api
+{
+
+    public partial class ApiScenariosTests
+    {
+        /// <summary>
+        /// Decomposable train and predict: Train on Iris multiclass problem, which will require
+        /// a transform on labels. Be able to reconstitute the pipeline for a prediction only task,
+        /// which will essentially "drop" the transform over labels, while retaining the property
+        /// that the predicted label for this has a key-type, the probability outputs for the classes
+        /// have the class labels as slot names, etc. This should be do-able without ugly compromises like,
+        /// say, injecting a dummy label.
+        /// </summary>
+        [Fact]
+        void DecomposableTrainAndPredictcs()
+        {
+            var dataPath = GetDataPath(IrisDataPath);
+            using (var env = new TlcEnvironment())
+            {
+                var loader = new TextLoader(env, MakeIrisTextLoaderArgs(), new MultiFileSource(dataPath));
+                var term = new TermTransform(env, loader, "Label");
+                var concat = new ConcatTransform(env, term, "Features", "SepalLength", "SepalWidth", "PetalLength", "PetalWidth");
+                var trainer = new SdcaMultiClassTrainer(env, new SdcaMultiClassTrainer.Arguments { MaxIterations = 100, Shuffle = true, NumThreads = 1 });
+
+                IDataView trainData = trainer.Info.WantCaching ? (IDataView)new CacheDataView(env, concat, prefetch: null) : concat;
+                var trainRoles = new RoleMappedData(trainData, label: "Label", feature: "Features");
+
+                // Auto-normalization.
+                NormalizeTransform.CreateIfNeeded(env, ref trainRoles, trainer);
+                var predictor = trainer.Train(new Runtime.TrainContext(trainRoles));
+
+                var scoreRoles = new RoleMappedData(concat, label: "Label", feature: "Features");
+                IDataScorerTransform scorer = ScoreUtils.GetScorer(predictor, scoreRoles, env, trainRoles.Schema);
+                
+                // Cut of term transform from pipeline.
+                var new_scorer = ApplyTransformUtils.ApplyAllTransformsToData(env, scorer, loader, term);
+                var keyToValue = new KeyToValueTransform(env, new_scorer, "PredictedLabel");
+                var model = env.CreatePredictionEngine<IrisData, IrisPrediction>(keyToValue);
+
+                var testLoader = new TextLoader(env, MakeIrisTextLoaderArgs(), new MultiFileSource(dataPath));
+                var testData = testLoader.AsEnumerable<IrisData>(env, false);
+                foreach (var input in testData.Take(20))
+                {
+                    var prediction = model.Predict(input);
+                    Assert.True(prediction.PredictedLabel == input.Label);
+                }
+            }
+        }
+    }
+}

test/Microsoft.ML.Tests/Scenarios/Api/FileBasedSavingOfData.cs

@@ -0,0 +1,48 @@
+using Microsoft.ML.Runtime.Data;
+using Microsoft.ML.Runtime.Data.IO;
+using Microsoft.ML.Runtime.Learners;
+using Xunit;
+
+namespace Microsoft.ML.Tests.Scenarios.Api
+{
+    public partial class ApiScenariosTests
+    {
+        /// <summary>
+        /// File-based saving of data: Come up with transform pipeline. Transform training and
+        /// test data, and save the featurized data to some file, using the .idv format.
+        /// Train and evaluate multiple models over that pre-featurized data. (Useful for
+        /// sweeping scenarios, where you are training many times on the same data,
+        /// and don't necessarily want to transform it every single time.)
+        /// </summary>
+        [Fact]
+        void FileBasedSavingOfData()
+        {
+            var dataPath = GetDataPath(SentimentDataPath);
+            var testDataPath = GetDataPath(SentimentTestPath);
+            
+            using (var env = new TlcEnvironment(seed: 1, conc: 1))
+            {
+                // Pipeline
+                var loader = new TextLoader(env, MakeSentimentTextLoaderArgs(), new MultiFileSource(dataPath));
+                
+                var trans = TextTransform.Create(env, MakeSentimentTextTransformArgs(), loader);
+                var saver = new BinarySaver(env, new BinarySaver.Arguments());
+                using (var ch = env.Start("SaveData"))
+                using (var file = env.CreateOutputFile("i.idv"))
+                {
+                    DataSaverUtils.SaveDataView(ch, saver, trans, file);
+                }
+
+                var binData = new BinaryLoader(env, new BinaryLoader.Arguments(), new MultiFileSource("i.idv"));
+                var trainRoles = new RoleMappedData(binData, label: "Label", feature: "Features");
+                var trainer = new LinearClassificationTrainer(env, new LinearClassificationTrainer.Arguments
+                {
+                    NumThreads = 1
+                });
+                var predictor = trainer.Train(new Runtime.TrainContext(trainRoles));
+                
+                DeleteOutputPath("temp.idv");
+            }
+        }
+    }
+}

test/Microsoft.ML.Tests/Scenarios/Api/SimpleTrainAndPredict.cs

@@ -114,6 +114,48 @@ private static TextTransform.Arguments MakeSentimentTextTransformArgs(bool norma
             };
         }
 
+        private static TextLoader.Arguments MakeIrisTextLoaderArgs()
+        {
+
+            return new TextLoader.Arguments()
+            {
+                Separator = "comma",
+                HasHeader = true,
+                Column = new[]
+                    {
+                        new TextLoader.Column()
+                        {
+                            Name = "SepalLength",
+                            Source = new [] { new TextLoader.Range() { Min=0, Max=0} },
+                            Type = DataKind.R4
+                        },
+                        new TextLoader.Column()
+                        {
+                            Name = "SepalWidth",
+                            Source = new [] { new TextLoader.Range() { Min=1, Max=1} },
+                            Type = DataKind.R4
+                        },
+                        new TextLoader.Column()
+                        {
+                            Name = "PetalLength",
+                            Source = new [] { new TextLoader.Range() { Min=2, Max=2} },
+                            Type = DataKind.R4
+                        },
+                        new TextLoader.Column()
+                        {
+                            Name = "PetalWidth",
+                            Source = new [] { new TextLoader.Range() { Min=3, Max=3} },
+                            Type = DataKind.R4
+                        },
+                        new TextLoader.Column()
+                        {
+                            Name = "Label",
+                            Source = new [] { new TextLoader.Range() { Min=4, Max=4} },
+                            Type = DataKind.Text
+                        }
+                    }
+            };
+        }
         private static TextLoader.Arguments MakeSentimentTextLoaderArgs()
         {
             return new TextLoader.Arguments()