Merge remote-tracking branch 'upstream/master' into parsingPerf

Author: adamsitnik

README.md

@@ -16,11 +16,11 @@ Along with these ML capabilities, this first release of ML.NET also brings the f
 
 [![NuGet Status](https://img.shields.io/nuget/v/Microsoft.ML.svg?style=flat)](https://www.nuget.org/packages/Microsoft.ML/)
 
-ML.NET runs on Windows, Linux, and macOS - any platform where x64 [.NET Core](https://github.com/dotnet/core) or later is available. In addition, .NET Framework on Windows x64 is also supported.
+ML.NET runs on Windows, Linux, and macOS using [.NET Core](https://github.com/dotnet/core), or Windows using .NET Framework. 64 bit is supported on all platforms. 32 bit is supported on Windows, except for TensorFlow, LightGBM, and ONNX related functionality.
 
-The current release is 0.6. Check out the [release notes](docs/release-notes/0.6/release-0.6.md) to see what's new.
+The current release is 0.7. Check out the [release notes](docs/release-notes/0.7/release-0.7.md) and [blog post](https://blogs.msdn.microsoft.com/dotnet/2018/11/08/announcing-ml-net-0-7-machine-learning-net/) to see what's new.
 
-First, ensure you have installed [.NET Core 2.0](https://www.microsoft.com/net/learn/get-started) or later. ML.NET also works on the .NET Framework. Note that ML.NET currently must run in a 64-bit process.
+First, ensure you have installed [.NET Core 2.1](https://www.microsoft.com/net/learn/get-started) or later. ML.NET also works on the .NET Framework 4.6.1 or later, but 4.7.2 or later is recommended.
 
 Once you have an app, you can install the ML.NET NuGet package from the .NET Core CLI using:
 ```
@@ -65,31 +65,32 @@ Here's an example of code to train a model to predict sentiment from text sample
 (You can find a sample of the legacy API [here](test/Microsoft.ML.Tests/Scenarios/SentimentPredictionTests.cs)):
 
 ```C#
-var env = new LocalEnvironment();
-var reader = TextLoader.CreateReader(env, ctx => (
-        Target: ctx.LoadFloat(2),
-        FeatureVector: ctx.LoadFloat(3, 6)),
-        separator: ',',
-        hasHeader: true);
-var data = reader.Read(new MultiFileSource(dataPath));
-var classification = new MulticlassClassificationContext(env);
-var learningPipeline = reader.MakeNewEstimator()
-    .Append(r => (
-    r.Target,
-    Prediction: classification.Trainers.Sdca(r.Target.ToKey(), r.FeatureVector)));
+var mlContext = new MLContext();
+var reader = mlContext.Data.TextReader(new TextLoader.Arguments
+        {
+        Column = new[] {
+            new TextLoader.Column("SentimentText", DataKind.Text, 1),
+            new TextLoader.Column("Label", DataKind.Bool, 0),
+        },
+        HasHeader = true,
+        Separator = ","
+});
+var data = reader.Read(dataPath);
+var learningPipeline = mlContext.Transforms.Text.FeaturizeText("SentimentText", "Features")
+        .Append(mlContext.BinaryClassification.Trainers.FastTree());
 var model = learningPipeline.Fit(data);
 
 ```
 
 Now from the model we can make inferences (predictions):
 
 ```C#
-var predictionFunc = model.MakePredictionFunction<SentimentInput, SentimentPrediction>(env);
+var predictionFunc = model.MakePredictionFunction<SentimentData, SentimentPrediction>(mlContext);
 var prediction = predictionFunc.Predict(new SentimentData
 {
     SentimentText = "Today is a great day!"
 });
-Console.WriteLine("prediction: " + prediction.Sentiment);
+Console.WriteLine("prediction: " + prediction.Prediction);
 ```
 A cookbook that shows how to use these APIs for a variety of existing and new scenarios can be found [here](docs/code/MlNetCookBook.md).
 

build/ci/phase-template.yml

@@ -11,7 +11,7 @@ phases:
       _phaseName: ${{ parameters.name }}
       _arch: ${{ parameters.architecture }}
     queue:
-      timeoutInMinutes: 40
+      timeoutInMinutes: 45
       parallel: 99
       matrix:
         Build_Debug:

docs/code/MlNetCookBook.md

@@ -1331,7 +1331,7 @@ var learningPipeline = reader.MakeNewEstimator()
 IEstimator<ITransformer> dynamicPipe = learningPipeline.AsDynamic;
 
 // Create a binary classification trainer.
-var binaryTrainer = mlContext.BinaryClassification.Trainers.AveragedPerceptron();
+var binaryTrainer = mlContext.BinaryClassification.Trainers.AveragedPerceptron("Label", "Features");
 
 // Append the OVA learner to the pipeline.
 dynamicPipe = dynamicPipe.Append(new Ova(mlContext, binaryTrainer));

docs/samples/Microsoft.ML.Samples/Dynamic/MatrixFactorization.cs

@@ -71,8 +71,10 @@ public static void MatrixFactorizationInMemoryData()
             // Create a matrix factorization trainer which may consume "Value" as the training label, "MatrixColumnIndex" as the
             // matrix's column index, and "MatrixRowIndex" as the matrix's row index. Here nameof(...) is used to extract field
             // names' in MatrixElement class.
-            var pipeline = new MatrixFactorizationTrainer(mlContext, nameof(MatrixElement.Value),
-                nameof(MatrixElement.MatrixColumnIndex), nameof(MatrixElement.MatrixRowIndex),
+            var pipeline = new MatrixFactorizationTrainer(mlContext, 
+                nameof(MatrixElement.MatrixColumnIndex),
+                nameof(MatrixElement.MatrixRowIndex),
+                nameof(MatrixElement.Value),
                 advancedSettings: s =>
                 {
                     s.NumIterations = 10;

docs/samples/Microsoft.ML.Samples/Dynamic/SDCA.cs

@@ -48,7 +48,7 @@ public static void SDCA_BinaryClassification()
             // Then append a binary classifier, setting the "Label" column as the label of the dataset, and 
             // the "Features" column produced by FeaturizeText as the features column. 
             var pipeline = mlContext.Transforms.Text.FeaturizeText("SentimentText", "Features")
-                    .Append(mlContext.BinaryClassification.Trainers.StochasticDualCoordinateAscent(label: "Sentiment", features: "Features", l2Const: 0.001f));
+                    .Append(mlContext.BinaryClassification.Trainers.StochasticDualCoordinateAscent(labelColumn: "Sentiment", featureColumn: "Features", l2Const: 0.001f));
 
             // Step 3: Run Cross-Validation on this pipeline.
             var cvResults = mlContext.BinaryClassification.CrossValidate(data, pipeline, labelColumn: "Sentiment");
@@ -60,8 +60,8 @@ public static void SDCA_BinaryClassification()
             // we could do so by tweaking the 'advancedSetting'.
             var advancedPipeline = mlContext.Transforms.Text.FeaturizeText("SentimentText", "Features")
                                   .Append(mlContext.BinaryClassification.Trainers.StochasticDualCoordinateAscent
-                                  (label: "Sentiment",
-                                   features: "Features",
+                                  (labelColumn: "Sentiment",
+                                   featureColumn: "Features",
                                    advancedSettings: s=>
                                        {
                                            s.ConvergenceTolerance = 0.01f;   // The learning rate for adjusting bias from being regularized

docs/samples/Microsoft.ML.Samples/Static/FastTreeBinaryClassification.cs

@@ -89,7 +89,7 @@ public static void FastTreeBinaryClassification()
                             row.Features,
                             numTrees: 100, // try: (int) 20-2000
                             numLeaves: 20, // try: (int) 2-128
-                            minDatapointsInLeafs: 10, // try: (int) 1-100
+                            minDatapointsInLeaves: 10, // try: (int) 1-100
                             learningRate: 0.2))) // try: (float) 0.025-0.4
                 .Append(row => (
                     Label: row.Label,

docs/samples/Microsoft.ML.Samples/Static/FastTreeRegression.cs

@@ -47,7 +47,7 @@ public static void FastTreeRegression()
                                             r.features,
                                             numTrees: 100, // try: (int) 20-2000
                                             numLeaves: 20, // try: (int) 2-128
-                                            minDatapointsInLeafs: 10, // try: (int) 1-100
+                                            minDatapointsInLeaves: 10, // try: (int) 1-100
                                             learningRate: 0.2, // try: (float) 0.025-0.4    
                                         onFit: p => pred = p)
                                 )

src/Microsoft.ML.Core/CommandLine/ArgumentAttribute.cs

@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-// This is separated from CmdParser.cs
-
 using System;
 using System.Linq;
 
@@ -15,7 +13,8 @@ namespace Microsoft.ML.Runtime.CommandLine
     /// as the destination of command line argument parsing.
     /// </summary>
     [AttributeUsage(AttributeTargets.Field)]
-    public class ArgumentAttribute : Attribute
+    [BestFriend]
+    internal class ArgumentAttribute : Attribute
     {
         public enum VisibilityType
         {
@@ -24,35 +23,23 @@ public enum VisibilityType
             EntryPointsOnly
         }
 
-        private ArgumentType _type;
         private string _shortName;
-        private string _helpText;
-        private bool _hide;
-        private double _sortOrder;
-        private string _nullName;
-        private bool _isInputFileName;
-        private string _specialPurpose;
-        private VisibilityType _visibility;
         private string _name;
-        private Type _signatureType;
 
         /// <summary>
         /// Allows control of command line parsing.
         /// </summary>
         /// <param name="type"> Specifies the error checking to be done on the argument. </param>
         public ArgumentAttribute(ArgumentType type)
         {
-            _type = type;
-            _sortOrder = 150;
+            Type = type;
+            SortOrder = 150;
         }
 
         /// <summary>
         /// The error checking to be done on the argument.
         /// </summary>
-        public ArgumentType Type
-        {
-            get { return _type; }
-        }
+        public ArgumentType Type { get; }
 
         /// <summary>
         /// The short name(s) of the argument.
@@ -64,7 +51,7 @@ public ArgumentType Type
         /// </summary>
         public string ShortName
         {
-            get { return _shortName; }
+            get => _shortName;
             set
             {
                 Contracts.Check(value == null || !(this is DefaultArgumentAttribute));
@@ -75,54 +62,26 @@ public string ShortName
         /// <summary>
         /// The help text for the argument.
         /// </summary>
-        public string HelpText
-        {
-            get { return _helpText; }
-            set { _helpText = value; }
-        }
+        public string HelpText { get; set; }
 
-        public bool Hide
-        {
-            get { return _hide; }
-            set { _hide = value; }
-        }
+        public bool Hide { get; set; }
 
-        public double SortOrder
-        {
-            get { return _sortOrder; }
-            set { _sortOrder = value; }
-        }
+        public double SortOrder { get; set; }
 
-        public string NullName
-        {
-            get { return _nullName; }
-            set { _nullName = value; }
-        }
+        public string NullName { get; set; }
 
-        public bool IsInputFileName
-        {
-            get { return _isInputFileName; }
-            set { _isInputFileName = value; }
-        }
+        public bool IsInputFileName { get; set; }
 
         /// <summary>
         /// Allows the GUI or other tools to inspect the intended purpose of the argument and pick a correct custom control.
         /// </summary>
-        public string Purpose
-        {
-            get { return _specialPurpose; }
-            set { _specialPurpose = value; }
-        }
+        public string Purpose { get; set; }
 
-        public VisibilityType Visibility
-        {
-            get { return _visibility; }
-            set { _visibility = value; }
-        }
+        public VisibilityType Visibility { get; set; }
 
         public string Name
         {
-            get { return _name; }
+            get => _name;
             set { _name = string.IsNullOrWhiteSpace(value) ? null : value; }
         }
 
@@ -136,15 +95,8 @@ public string[] Aliases
             }
         }
 
-        public bool IsRequired
-        {
-            get { return ArgumentType.Required == (_type & ArgumentType.Required); }
-        }
+        public bool IsRequired => ArgumentType.Required == (Type & ArgumentType.Required);
 
-        public Type SignatureType
-        {
-            get { return _signatureType; }
-            set { _signatureType = value; }
-        }
+        public Type SignatureType { get; set; }
     }
 }

src/Microsoft.ML.Core/CommandLine/ArgumentType.cs

@@ -0,0 +1,54 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+
+namespace Microsoft.ML.Runtime.CommandLine
+{
+    /// <summary>
+    /// Used to control parsing of command line arguments.
+    /// </summary>
+    [Flags]
+    [BestFriend]
+    internal enum ArgumentType
+    {
+        /// <summary>
+        /// Indicates that this field is required. An error will be displayed
+        /// if it is not present when parsing arguments.
+        /// </summary>
+        Required = 0x01,
+
+        /// <summary>
+        /// Only valid in conjunction with Multiple.
+        /// Duplicate values will result in an error.
+        /// </summary>
+        Unique = 0x02,
+
+        /// <summary>
+        /// Inidicates that the argument may be specified more than once.
+        /// Only valid if the argument is a collection
+        /// </summary>
+        Multiple = 0x04,
+
+        /// <summary>
+        /// The default type for non-collection arguments.
+        /// The argument is not required, but an error will be reported if it is specified more than once.
+        /// </summary>
+        AtMostOnce = 0x00,
+
+        /// <summary>
+        /// For non-collection arguments, when the argument is specified more than
+        /// once no error is reported and the value of the argument is the last
+        /// value which occurs in the argument list.
+        /// </summary>
+        LastOccurenceWins = Multiple,
+
+        /// <summary>
+        /// The default type for collection arguments.
+        /// The argument is permitted to occur multiple times, but duplicate
+        /// values will cause an error to be reported.
+        /// </summary>
+        MultipleUnique = Multiple | Unique,
+    }
+}

src/Microsoft.ML.Core/CommandLine/CharCursor.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.ML.Runtime.CommandLine
 {
-    public sealed class CharCursor
+    internal sealed class CharCursor
     {
         private readonly string _text;
         private readonly int _ichLim;

src/Microsoft.ML.Core/CommandLine/CmdLexer.cs

@@ -2,13 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Text;
-using Microsoft.ML.Runtime.Internal.Utilities;
 
 namespace Microsoft.ML.Runtime.CommandLine
 {
-    public sealed class CmdLexer
+    [BestFriend]
+    internal sealed class CmdLexer
     {
         private CharCursor _curs;