Add SetMaximumMemoryUsageInMegaByte in AutoMLExperiment

src/Microsoft.ML.AutoML/API/AutoCatalog.cs

@@ -654,18 +654,18 @@ internal SweepablePipeline ImagePathFeaturizer(string outputColumnName, string i
         /// them into a single feature column as output.
         /// </summary>
         /// <param name="data">input data.</param>
-        /// <param name="catalogColumns">columns that should be treated as catalog. If not specified, it will automatically infer if a column is catalog or not.</param>
+        /// <param name="catelogicalColumns">columns that should be treated as catalog. If not specified, it will automatically infer if a column is catalog or not.</param>
         /// <param name="numericColumns">columns that should be treated as numeric. If not specified, it will automatically infer if a column is catalog or not.</param>
         /// <param name="textColumns">columns that should be treated as text. If not specified, it will automatically infer if a column is catalog or not.</param>
         /// <param name="imagePathColumns">columns that should be treated as image path. If not specified, it will automatically infer if a column is catalog or not.</param>
         /// <param name="outputColumnName">output feature column.</param>
         /// <param name="excludeColumns">columns that won't be included when featurizing, like label</param>
-        public SweepablePipeline Featurizer(IDataView data, string outputColumnName = "Features", string[] catalogColumns = null, string[] numericColumns = null, string[] textColumns = null, string[] imagePathColumns = null, string[] excludeColumns = null)
+        public SweepablePipeline Featurizer(IDataView data, string outputColumnName = "Features", string[] catelogicalColumns = null, string[] numericColumns = null, string[] textColumns = null, string[] imagePathColumns = null, string[] excludeColumns = null)
         {
             Contracts.CheckValue(data, nameof(data));
 
             // validate if there's overlapping among catalogColumns, numericColumns, textColumns and excludeColumns
-            var overallColumns = new string[][] { catalogColumns, numericColumns, textColumns, excludeColumns }
+            var overallColumns = new string[][] { catelogicalColumns, numericColumns, textColumns, excludeColumns }
                                     .Where(c => c != null)
                                     .SelectMany(c => c);
 
@@ -684,9 +684,9 @@ public SweepablePipeline Featurizer(IDataView data, string outputColumnName = "F
                 }
             }
 
-            if (catalogColumns != null)
+            if (catelogicalColumns != null)
             {
-                foreach (var catalogColumn in catalogColumns)
+                foreach (var catalogColumn in catelogicalColumns)
                 {
                     columnInfo.CategoricalColumnNames.Add(catalogColumn);
                 }

src/Microsoft.ML.AutoML/API/AutoMLExperimentExtension.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Text;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.ML.Runtime;
 using static Microsoft.ML.DataOperationsCatalog;
 
 namespace Microsoft.ML.AutoML
@@ -144,6 +145,18 @@ public static AutoMLExperiment SetPipeline(this AutoMLExperiment experiment, Swe
             return experiment;
         }
 
+        public static AutoMLExperiment SetPerformanceMonitor(this AutoMLExperiment experiment, int checkIntervalInMilliseconds = 1000)
+        {
+            experiment.SetPerformanceMonitor((service) =>
+            {
+                var channel = service.GetService<IChannel>();
+
+                return new DefaultPerformanceMonitor(channel, checkIntervalInMilliseconds);
+            });
+
+            return experiment;
+        }
+
         private static AutoMLExperiment SetEvaluateMetric<TEvaluateMetricManager>(this AutoMLExperiment experiment, TEvaluateMetricManager metricManager)
             where TEvaluateMetricManager : class, IEvaluateMetricManager
         {

src/Microsoft.ML.AutoML/API/BinaryClassificationExperiment.cs

@@ -6,6 +6,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.ML.Data;
 using Microsoft.ML.Runtime;
@@ -144,6 +146,10 @@ internal BinaryClassificationExperiment(MLContext context, BinaryExperimentSetti
                   TrainerExtensionUtil.GetTrainerNames(settings.Trainers))
         {
             _experiment = context.Auto().CreateExperiment();
+            if (settings.MaximumMemoryUsageInMegaByte is double d)
+            {
+                _experiment.SetMaximumMemoryUsageInMegaByte(d);
+            }
         }
 
         public override ExperimentResult<BinaryClassificationMetrics> Execute(IDataView trainData, ColumnInformation columnInformation, IEstimator<ITransformer> preFeaturizer = null, IProgress<RunDetail<BinaryClassificationMetrics>> progressHandler = null)
@@ -332,7 +338,7 @@ private SweepablePipeline CreateBinaryClassificationPipeline(IDataView trainData
 
     internal class BinaryClassificationRunner : ITrialRunner
     {
-        private readonly MLContext _context;
+        private MLContext _context;
         private readonly IDatasetManager _datasetManager;
         private readonly IMetricManager _metricManager;
         private readonly SweepablePipeline _pipeline;
@@ -346,6 +352,12 @@ public BinaryClassificationRunner(MLContext context, IDatasetManager datasetMana
             _rnd = settings.Seed.HasValue ? new Random(settings.Seed.Value) : new Random();
         }
 
+        public void Dispose()
+        {
+            _context.CancelExecution();
+            _context = null;
+        }
+
         public TrialResult Run(TrialSettings settings)
         {
             if (_metricManager is BinaryMetricManager metricManager)
@@ -421,5 +433,27 @@ public TrialResult Run(TrialSettings settings)
 
             throw new ArgumentException($"The runner metric manager is of type {_metricManager.GetType()} which expected to be of type {typeof(ITrainTestDatasetManager)} or {typeof(ICrossValidateDatasetManager)}");
         }
+
+        public Task<TrialResult> RunAsync(TrialSettings settings, CancellationToken ct)
+        {
+            try
+            {
+                using (var ctRegistration = ct.Register(() =>
+                {
+                    _context?.CancelExecution();
+                }))
+                {
+                    return Task.Run(() => Run(settings));
+                }
+            }
+            catch (Exception ex) when (ct.IsCancellationRequested)
+            {
+                throw new OperationCanceledException(ex.Message, ex.InnerException);
+            }
+            catch (Exception)
+            {
+                throw;
+            }
+        }
     }
 }

src/Microsoft.ML.AutoML/API/ExperimentSettings.cs

@@ -2,6 +2,7 @@
 // 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.Threading;
 
 namespace Microsoft.ML.AutoML
@@ -56,6 +57,8 @@ public abstract class ExperimentSettings
         /// <value>The default value is <see cref="CacheBeforeTrainer.Auto"/>.</value>
         public CacheBeforeTrainer CacheBeforeTrainer { get; set; }
 
+        public double? MaximumMemoryUsageInMegaByte { get; set; }
+
         internal int MaxModels;
 
         /// <summary>

src/Microsoft.ML.AutoML/API/MulticlassClassificationExperiment.cs

@@ -6,6 +6,8 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.ML.Data;
 using Microsoft.ML.Runtime;
@@ -135,6 +137,11 @@ internal MulticlassClassificationExperiment(MLContext context, MulticlassExperim
                   TrainerExtensionUtil.GetTrainerNames(settings.Trainers))
         {
             _experiment = context.Auto().CreateExperiment();
+
+            if (settings.MaximumMemoryUsageInMegaByte is double d)
+            {
+                _experiment.SetMaximumMemoryUsageInMegaByte(d);
+            }
         }
 
         public override ExperimentResult<MulticlassClassificationMetrics> Execute(IDataView trainData, ColumnInformation columnInformation, IEstimator<ITransformer> preFeaturizer = null, IProgress<RunDetail<MulticlassClassificationMetrics>> progressHandler = null)
@@ -189,7 +196,6 @@ public override ExperimentResult<MulticlassClassificationMetrics> Execute(IDataV
 
             return result;
         }
-
         public override ExperimentResult<MulticlassClassificationMetrics> Execute(IDataView trainData, IDataView validationData, ColumnInformation columnInformation, IEstimator<ITransformer> preFeaturizer = null, IProgress<RunDetail<MulticlassClassificationMetrics>> progressHandler = null)
         {
             var label = columnInformation.LabelColumnName;
@@ -333,7 +339,7 @@ private SweepablePipeline CreateMulticlassClassificationPipeline(IDataView train
 
     internal class MulticlassClassificationRunner : ITrialRunner
     {
-        private readonly MLContext _context;
+        private MLContext _context;
         private readonly IDatasetManager _datasetManager;
         private readonly IMetricManager _metricManager;
         private readonly SweepablePipeline _pipeline;
@@ -424,5 +430,33 @@ public TrialResult Run(TrialSettings settings)
 
             throw new ArgumentException($"The runner metric manager is of type {_metricManager.GetType()} which expected to be of type {typeof(ITrainTestDatasetManager)} or {typeof(ICrossValidateDatasetManager)}");
         }
+
+        public Task<TrialResult> RunAsync(TrialSettings settings, CancellationToken ct)
+        {
+            try
+            {
+                using (var ctRegistration = ct.Register(() =>
+                {
+                    _context?.CancelExecution();
+                }))
+                {
+                    return Task.Run(() => Run(settings));
+                }
+            }
+            catch (Exception ex) when (ct.IsCancellationRequested)
+            {
+                throw new OperationCanceledException(ex.Message, ex.InnerException);
+            }
+            catch (Exception)
+            {
+                throw;
+            }
+        }
+
+        public void Dispose()
+        {
+            _context.CancelExecution();
+            _context = null;
+        }
     }
 }