Forecasting interface with a unit-test.

Author: codemzs

src/Microsoft.ML.TimeSeries/AdaptiveSingularSpectrumSequenceModeler.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Numerics;
 using Microsoft.ML;
 using Microsoft.ML.Data;
@@ -22,7 +23,7 @@ namespace Microsoft.ML.Transforms.TimeSeries
     /// This class implements basic Singular Spectrum Analysis (SSA) model for modeling univariate time-series.
     /// For the details of the model, refer to http://arxiv.org/pdf/1206.6910.pdf.
     /// </summary>
-    internal sealed class AdaptiveSingularSpectrumSequenceModeler : SequenceModelerBase<Single, Single>
+    public sealed class AdaptiveSingularSpectrumSequenceModeler : SequenceModelerBase<Single, Single>, ICanForecast<float>
     {
         internal const string LoaderSignature = "SSAModel";
 
@@ -1546,5 +1547,64 @@ internal static void ComputeForecastIntervals(ref SsaForecastResult forecast, Si
             forecast.UpperBound = upper.Commit();
             forecast.LowerBound = lower.Commit();
         }
+
+        public void Train(IDataView dataView, string inputColumnName) => Train(new RoleMappedData(dataView, null, inputColumnName));
+
+        public float[] Forecast(int horizon)
+        {
+            ForecastResultBase<float> result = null;
+            Forecast(ref result, horizon);
+            return result.PointForecast.GetValues().ToArray();
+        }
+
+        public void Update(IDataView dataView, string inputColumnName)
+        {
+            _host.CheckParam(dataView != null, nameof(dataView), "The input series for updating cannot be null.");
+
+            var data = new RoleMappedData(dataView, null, inputColumnName);
+            if (data.Schema.Feature.Type != NumberType.Float)
+                throw _host.ExceptUserArg(nameof(data.Schema.Feature.Name), "The time series input column has " +
+                    "type '{0}', but must be a float.", data.Schema.Feature.Type);
+
+            int col = data.Schema.Feature.Index;
+            using (var cursor = data.Data.GetRowCursor(c => c == col))
+            {
+                var getVal = cursor.GetGetter<Single>(col);
+                Single val = default(Single);
+                while (cursor.MoveNext())
+                {
+                    getVal(ref val);
+                    if (!Single.IsNaN(val))
+                        Consume(ref val);
+                }
+            }
+        }
+
+        public void Checkpoint(IHostEnvironment env, string filePath)
+        {
+            using (var file = File.Create(filePath))
+            {
+                using (var ch = env.Start("Saving SSA forecasting model."))
+                {
+                    using (var rep = RepositoryWriter.CreateNew(file, ch))
+                    {
+                        ModelSaveContext.SaveModel(rep, this, LoaderSignature);
+                        rep.Commit();
+                    }
+                }
+            }
+        }
+
+        public AdaptiveSingularSpectrumSequenceModeler LoadFrom(IHostEnvironment env, string filePath)
+        {
+            using (var file = File.OpenRead(filePath))
+            {
+                using (var rep = RepositoryReader.Open(file, env))
+                {
+                    ModelLoadContext.LoadModel<AdaptiveSingularSpectrumSequenceModeler, SignatureLoadModel>(env, out var model, rep, LoaderSignature);
+                    return model;
+                }
+            }
+        }
     }
 }

src/Microsoft.ML.TimeSeries/PredictionFunction.cs

@@ -11,6 +11,15 @@
 
 namespace Microsoft.ML.Transforms.TimeSeries
 {
+    internal interface ICanForecast<out T>
+    {
+        void Train(IDataView dataView, string inputColumnName);
+        T[] Forecast(int horizon);
+        void Update(IDataView dataView, string inputColumnName);
+        void Checkpoint(IHostEnvironment env, string filePath);
+        AdaptiveSingularSpectrumSequenceModeler LoadFrom(IHostEnvironment env, string filePath);
+    }
+
     internal interface IStatefulRowToRowMapper : IRowToRowMapper
     {
     }

test/Microsoft.ML.TimeSeries.Tests/TimeSeriesDirectApi.cs

@@ -334,5 +334,50 @@ public void AnomalyDetectionWithSrCnn()
                 k += 1;
             }
         }
+
+        [ConditionalFact(typeof(BaseTestBaseline), nameof(BaseTestBaseline.LessThanNetCore30OrNotNetCore))]
+        public void Forecasting()
+        {
+            const int SeasonalitySize = 10;
+            const int NumberOfSeasonsInTraining = 5;
+
+            List<Data> data = new List<Data>();
+
+            var ml = new MLContext(seed: 1, conc: 1);
+            var dataView = ml.CreateStreamingDataView(data);
+
+            for (int j = 0; j < NumberOfSeasonsInTraining; j++)
+                for (int i = 0; i < SeasonalitySize; i++)
+                    data.Add(new Data(i));
+
+            // Create forecasting model.
+            var model = new AdaptiveSingularSpectrumSequenceModeler(ml, data.Count, SeasonalitySize + 1, SeasonalitySize,
+                1, AdaptiveSingularSpectrumSequenceModeler.RankSelectionMethod.Exact, null, SeasonalitySize / 2, false, false);
+
+            // Train.
+            model.Train(dataView, "Value");
+
+            // Forecast.
+            var forecast = model.Forecast(5);
+
+            // Update with new observations.
+            model.Update(dataView, "Value");
+
+            // Checkpoint.
+            model.Checkpoint(ml, "model.zip");
+
+            // Load the checkpointed model from disk.
+            var modelCopy = model.LoadFrom(ml, "model.zip");
+
+            // Forecast with the checkpointed model loaded from disk.
+            var forecastCopy = modelCopy.Forecast(5);
+
+            // Forecast with the original model(that was checkpointed to disk).
+            forecast = model.Forecast(5);
+
+            // Both the forecasted values from model loaded from disk and 
+            // already in memory model should be the same.
+            Assert.Equal(forecast, forecastCopy);
+        }
     }
 }