Add a test

Author: wschin

src/Microsoft.ML.FastTree/Representation/TreeRegressorCollection.cs

@@ -13,7 +13,7 @@ namespace Microsoft.ML.FastTree
     /// <see cref="TreeEnsemble{T}"/>, we need to compute the output values of all trees in <see cref="Trees"/>,
     /// scale those values via <see cref="TreeWeights"/>, and finally sum the scaled values and <see cref="Bias"/> up.
     /// </summary>
-    public class TreeEnsemble<T> where T : RegressionTreeBase
+    public sealed class TreeEnsemble<T> where T : RegressionTreeBase
     {
         /// <summary>
         /// When doing prediction, this is a value added to the weighted sum of all <see cref="Trees"/>' outputs.

src/Microsoft.ML.FastTree/TreeEnsemble/QuantileRegressionTree.cs

@@ -117,9 +117,9 @@ internal void ExtractLeafSamplesAndTheirWeights(out double[][] leafSamples, out
                         leafSamples[i][j] = _labelsDistribution[i * sampleCountPerLeaf + j];
                     else
                         // No training label is available, so the i-th leaf's value is used directly. Note that sampleCountPerLeaf must be 1 in this case.
-                        leafSampleWeights[i][j] = LeafValues[i];
+                        leafSamples[i][j] = LeafValues[i];
                     if (_instanceWeights != null)
-                        leafSamples[i][j] = _instanceWeights[i * sampleCountPerLeaf + j];
+                        leafSampleWeights[i][j] = _instanceWeights[i * sampleCountPerLeaf + j];
                     else
                         leafSampleWeights[i][j] = 1.0;
                 }

src/Microsoft.ML.SamplesUtils/SamplesDatasetUtils.cs

@@ -271,6 +271,37 @@ public static  IEnumerable<BinaryLabelFloatFeatureVectorSample> GenerateBinaryLa
             return data;
         }
 
+        public class FloatLabelFloatFeatureVectorSample
+        {
+            public float Label;
+
+            [VectorType(_simpleBinaryClassSampleFeatureLength)]
+            public float[] Features;
+        }
+
+        public static  IEnumerable<FloatLabelFloatFeatureVectorSample> GenerateFloatLabelFloatFeatureVectorSamples(int exampleCount)
+        {
+            var rnd = new Random(0);
+            var data = new List<FloatLabelFloatFeatureVectorSample>();
+            for (int i = 0; i < exampleCount; ++i)
+            {
+                // Initialize an example with a random label and an empty feature vector.
+                var sample = new FloatLabelFloatFeatureVectorSample() { Label = rnd.Next() % 2, Features = new float[_simpleBinaryClassSampleFeatureLength] };
+                // Fill feature vector according the assigned label.
+                for (int j = 0; j < _simpleBinaryClassSampleFeatureLength; ++j)
+                {
+                    var value = (float)rnd.NextDouble();
+                    // Positive class gets larger feature value.
+                    if (sample.Label == 0)
+                        value += 0.2f;
+                    sample.Features[j] = value;
+                }
+
+                data.Add(sample);
+            }
+            return data;
+        }
+
         public class FfmExample
         {
             public bool Label;

test/Microsoft.ML.Tests/Scenarios/Api/Estimators/IntrospectiveTraining.cs

@@ -5,6 +5,7 @@
 using Microsoft.ML.Data;
 using Microsoft.ML.Internal.Internallearn;
 using Microsoft.ML.RunTests;
+using Microsoft.ML.SamplesUtils;
 using Microsoft.ML.Trainers;
 using Microsoft.ML.Trainers.FastTree;
 using Xunit;
@@ -56,15 +57,15 @@ public void FastTreeClassificationIntrospectiveTraining()
 
             BinaryPredictionTransformer<IPredictorWithFeatureWeights<float>> pred = null;
 
-            var pipeline = ml.Transforms.Text.FeaturizeText("SentimentText", "Features")
+            var pipeline = ml.Transforms.Text.FeaturizeText("Features", "SentimentText")
                 .AppendCacheCheckpoint(ml)
                 .Append(trainer.WithOnFitDelegate(p => pred = p));
 
             // Train.
             var model = pipeline.Fit(data);
 
             // Extract the learned GBDT model.
-            var treeCollection = ((FastTreeBinaryModelParameters)((Internal.Calibration.FeatureWeightsCalibratedPredictor)pred.Model).SubPredictor).TrainedTreeEnsemble;
+            var treeCollection = ((FastForestBinaryModelParameters)((Internal.Calibration.FeatureWeightsCalibratedPredictor)pred.Model).SubPredictor).TrainedTreeEnsemble;
 
             // Inspect properties in the extracted model.
             Assert.Equal(3, treeCollection.Trees.Count);
@@ -80,11 +81,63 @@ public void FastTreeClassificationIntrospectiveTraining()
             Assert.Equal(tree.LteChild, new int[] { 2, -2, -1, -3 });
             Assert.Equal(tree.GtChild, new int[] { 1, 3, -4, -5 });
             Assert.Equal(tree.NumericalSplitFeatureIndexes, new int[] { 14, 294, 633, 266 });
-            Assert.Equal(tree.NumericalSplitThresholds, new float[] { 0.0911167f, 0.06509889f, 0.019873254f, 0.0361835f });
+            var expectedThresholds = new float[] { 0.0911167f, 0.06509889f, 0.019873254f, 0.0361835f };
+            for (int i = 0; i < tree.NumNodes; ++i)
+                Assert.Equal(expectedThresholds[i], tree.NumericalSplitThresholds[i], 6);
             Assert.All(tree.CategoricalSplitFlags, flag => Assert.False(flag));
 
             Assert.Equal(0, tree.GetCategoricalSplitFeaturesAt(0).Count);
             Assert.Equal(0, tree.GetCategoricalCategoricalSplitFeatureRangeAt(0).Count);
         }
+
+        [Fact]
+        public void FastForestRegressionIntrospectiveTraining()
+        {
+            var ml = new MLContext(seed: 1, conc: 1);
+            var data = DatasetUtils.GenerateFloatLabelFloatFeatureVectorSamples(1000);
+            var dataView = ml.Data.ReadFromEnumerable(data);
+
+            RegressionPredictionTransformer<FastForestRegressionModelParameters> pred = null;
+            var trainer = ml.Regression.Trainers.FastForest(numLeaves: 5, numTrees: 3).WithOnFitDelegate(p => pred = p);
+
+            // Train.
+            var model = trainer.Fit(dataView);
+
+            // Extract the learned RF model.
+            var treeCollection = pred.Model.TrainedTreeEnsemble;
+
+            // Inspect properties in the extracted model.
+            Assert.Equal(3, treeCollection.Trees.Count);
+            Assert.Equal(3, treeCollection.TreeWeights.Count);
+            Assert.Equal(0, treeCollection.Bias);
+            Assert.All(treeCollection.TreeWeights, weight => Assert.Equal(1.0, weight));
+
+            // Inspect the last tree.
+            var tree = treeCollection.Trees[2];
+
+            Assert.Equal(5, tree.NumLeaves);
+            Assert.Equal(4, tree.NumNodes);
+            Assert.Equal(tree.LteChild, new int[] { -1, -2, -3, -4 });
+            Assert.Equal(tree.GtChild, new int[] { 1, 2, 3, -5 });
+            Assert.Equal(tree.NumericalSplitFeatureIndexes, new int[] { 9, 0, 1, 8 });
+            var expectedThresholds = new float[] { 0.208134219f, 0.198336035f, 0.202952743f, 0.205061346f };
+            for (int i = 0; i < tree.NumNodes; ++i)
+                Assert.Equal(expectedThresholds[i], tree.NumericalSplitThresholds[i], 6);
+            Assert.All(tree.CategoricalSplitFlags, flag => Assert.False(flag));
+
+            Assert.Equal(0, tree.GetCategoricalSplitFeaturesAt(0).Count);
+            Assert.Equal(0, tree.GetCategoricalCategoricalSplitFeatureRangeAt(0).Count);
+
+            var samples = new double[] { 0.97468354430379744, 1.0, 0.97727272727272729, 0.972972972972973, 0.26124197002141325 };
+            for (int i = 0; i < tree.NumLeaves; ++i)
+            {
+                var sample = tree.GetLeafSamplesAt(i);
+                Assert.Single(sample);
+                Assert.Equal(samples[i], sample[0], 6);
+                var weight = tree.GetLeafSampleWeightsAt(i);
+                Assert.Single(weight);
+                Assert.Equal(1, weight[0]);
+            }
+        }
     }
 }