Prediction engine for time series.

src/Microsoft.ML.Api/DataViewConstructionUtils.cs

@@ -16,6 +16,7 @@ namespace Microsoft.ML.Runtime.Api
     /// <summary>
     /// A helper class to create data views based on the user-provided types.
     /// </summary>
+    [BestFriend]
     internal static class DataViewConstructionUtils
     {
         public static IDataView CreateFromList<TRow>(IHostEnvironment env, IList<TRow> data,

src/Microsoft.ML.Api/PredictionEngine.cs

@@ -124,6 +124,29 @@ public void Reset()
         }
     }
 
+    public sealed class PredictionEngine<TSrc, TDst> : PredictionEngineBase<TSrc, TDst>
+       where TSrc : class
+       where TDst : class, new()
+    {
+        internal PredictionEngine(IHostEnvironment env, Stream modelStream, bool ignoreMissingColumns,
+            SchemaDefinition inputSchemaDefinition = null, SchemaDefinition outputSchemaDefinition = null)
+            : base(env, modelStream, ignoreMissingColumns, inputSchemaDefinition, outputSchemaDefinition)
+        {
+        }
+
+        internal PredictionEngine(IHostEnvironment env, IDataView dataPipe, bool ignoreMissingColumns,
+            SchemaDefinition inputSchemaDefinition = null, SchemaDefinition outputSchemaDefinition = null)
+            : base(env, dataPipe, ignoreMissingColumns, inputSchemaDefinition, outputSchemaDefinition)
+        {
+        }
+
+        internal PredictionEngine(IHostEnvironment env, ITransformer transformer, bool ignoreMissingColumns,
+            SchemaDefinition inputSchemaDefinition = null, SchemaDefinition outputSchemaDefinition = null)
+            : base(env, transformer, ignoreMissingColumns, inputSchemaDefinition, outputSchemaDefinition)
+        {
+        }
+    }
+
     /// <summary>
     /// A class that runs the previously trained model (and the preceding transform pipeline) on the
     /// in-memory data, one example at a time.
@@ -132,20 +155,22 @@ public void Reset()
     /// </summary>
     /// <typeparam name="TSrc">The user-defined type that holds the example.</typeparam>
     /// <typeparam name="TDst">The user-defined type that holds the prediction.</typeparam>
-    public sealed class PredictionEngine<TSrc, TDst>
+    public abstract class PredictionEngineBase<TSrc, TDst>
         where TSrc : class
         where TDst : class, new()
     {
         private readonly DataViewConstructionUtils.InputRow<TSrc> _inputRow;
         private readonly IRowReadableAs<TDst> _outputRow;
         private readonly Action _disposer;
 
-        internal PredictionEngine(IHostEnvironment env, Stream modelStream, bool ignoreMissingColumns,
+        [BestFriend]
+        internal PredictionEngineBase(IHostEnvironment env, Stream modelStream, bool ignoreMissingColumns,
             SchemaDefinition inputSchemaDefinition = null, SchemaDefinition outputSchemaDefinition = null)
             : this(env, StreamChecker(env, modelStream), ignoreMissingColumns, inputSchemaDefinition, outputSchemaDefinition)
         {
         }
 
+        [BestFriend]
         private static Func<Schema, IRowToRowMapper> StreamChecker(IHostEnvironment env, Stream modelStream)
         {
             env.CheckValue(modelStream, nameof(modelStream));
@@ -158,13 +183,15 @@ private static Func<Schema, IRowToRowMapper> StreamChecker(IHostEnvironment env,
             };
         }
 
-        internal PredictionEngine(IHostEnvironment env, IDataView dataPipe, bool ignoreMissingColumns,
+        [BestFriend]
+        internal PredictionEngineBase(IHostEnvironment env, IDataView dataPipe, bool ignoreMissingColumns,
             SchemaDefinition inputSchemaDefinition = null, SchemaDefinition outputSchemaDefinition = null)
             : this(env, new TransformWrapper(env, env.CheckRef(dataPipe, nameof(dataPipe))), ignoreMissingColumns, inputSchemaDefinition, outputSchemaDefinition)
         {
         }
 
-        internal PredictionEngine(IHostEnvironment env, ITransformer transformer, bool ignoreMissingColumns,
+        [BestFriend]
+        internal PredictionEngineBase(IHostEnvironment env, ITransformer transformer, bool ignoreMissingColumns,
             SchemaDefinition inputSchemaDefinition = null, SchemaDefinition outputSchemaDefinition = null)
             : this(env, TransformerChecker(env, transformer), ignoreMissingColumns, inputSchemaDefinition, outputSchemaDefinition)
         {
@@ -177,20 +204,25 @@ private static Func<Schema, IRowToRowMapper> TransformerChecker(IExceptionContex
             return transformer.GetRowToRowMapper;
         }
 
-        private PredictionEngine(IHostEnvironment env, Func<Schema, IRowToRowMapper> makeMapper, bool ignoreMissingColumns,
+        internal PredictionEngineBase(IHostEnvironment env, Func<Schema, IRowToRowMapper> makeMapper, bool ignoreMissingColumns,
                  SchemaDefinition inputSchemaDefinition, SchemaDefinition outputSchemaDefinition)
         {
             Contracts.CheckValue(env, nameof(env));
             env.AssertValue(makeMapper);
-
             _inputRow = DataViewConstructionUtils.CreateInputRow<TSrc>(env, inputSchemaDefinition);
-            var mapper = makeMapper(_inputRow.Schema);
+
+            PredictionEngineCore(env, _inputRow, makeMapper(_inputRow.Schema), ignoreMissingColumns, inputSchemaDefinition, outputSchemaDefinition, out _disposer, out _outputRow);
+        }
+
+        internal virtual void PredictionEngineCore(IHostEnvironment env, DataViewConstructionUtils.InputRow<TSrc> inputRow, IRowToRowMapper mapper, bool ignoreMissingColumns,
+                 SchemaDefinition inputSchemaDefinition, SchemaDefinition outputSchemaDefinition, out Action disposer, out IRowReadableAs<TDst> outputRow)
+        {
             var cursorable = TypedCursorable<TDst>.Create(env, new EmptyDataView(env, mapper.Schema), ignoreMissingColumns, outputSchemaDefinition);
-            var outputRow = mapper.GetRow(_inputRow, col => true, out _disposer);
-            _outputRow = cursorable.GetRow(outputRow);
+            var outputRowLocal = mapper.GetRow(_inputRow, col => true, out disposer);
+            outputRow = cursorable.GetRow(outputRowLocal);
         }
 
-        ~PredictionEngine()
+        ~PredictionEngineBase()
         {
             _disposer?.Invoke();
         }
@@ -207,19 +239,24 @@ public TDst Predict(TSrc example)
             return result;
         }
 
+        public void ExtractValues(TSrc example) => _inputRow.ExtractValues(example);
+
+        public void FillValues(TDst prediction) => _outputRow.FillValues(prediction);
+
         /// <summary>
         /// Run prediction pipeline on one example.
         /// </summary>
         /// <param name="example">The example to run on.</param>
         /// <param name="prediction">The object to store the prediction in. If it's <c>null</c>, a new one will be created, otherwise the old one
         /// is reused.</param>
-        public void Predict(TSrc example, ref TDst prediction)
+        public virtual void Predict(TSrc example, ref TDst prediction)
         {
             Contracts.CheckValue(example, nameof(example));
-            _inputRow.ExtractValues(example);
+            ExtractValues(example);
             if (prediction == null)
                 prediction = new TDst();
-            _outputRow.FillValues(prediction);
+
+            FillValues(prediction);
         }
     }
 

src/Microsoft.ML.Api/PredictionFunction.cs

@@ -7,30 +7,40 @@
 
 namespace Microsoft.ML.Runtime.Data
 {
+    public sealed class PredictionFunction<TSrc, TDst> : PredictionFunctionBase<TSrc, TDst>
+            where TSrc : class
+            where TDst : class, new()
+    {
+        public PredictionFunction(IHostEnvironment env, ITransformer transformer) : base(env, transformer) { }
+    }
+
     /// <summary>
     /// A prediction engine class, that takes instances of <typeparamref name="TSrc"/> through
     /// the transformer pipeline and produces instances of <typeparamref name="TDst"/> as outputs.
     /// </summary>
-    public sealed class PredictionFunction<TSrc, TDst>
+    public abstract class PredictionFunctionBase<TSrc, TDst>
                 where TSrc : class
                 where TDst : class, new()
     {
-        private readonly PredictionEngine<TSrc, TDst> _engine;
+        private readonly PredictionEngineBase<TSrc, TDst> _engine;
 
         /// <summary>
         /// Create an instance of <see cref="PredictionFunction{TSrc, TDst}"/>.
         /// </summary>
         /// <param name="env">The host environment.</param>
         /// <param name="transformer">The model (transformer) to use for prediction.</param>
-        public PredictionFunction(IHostEnvironment env, ITransformer transformer)
+        public PredictionFunctionBase(IHostEnvironment env, ITransformer transformer)
         {
             Contracts.CheckValue(env, nameof(env));
             env.CheckValue(transformer, nameof(transformer));
 
             IDataView dv = env.CreateDataView(new TSrc[0]);
-            _engine = env.CreatePredictionEngine<TSrc, TDst>(transformer);
+            CreatePredictionEngine(env, transformer, out _engine);
         }
 
+        internal virtual void CreatePredictionEngine(IHostEnvironment env, ITransformer transformer, out PredictionEngineBase<TSrc, TDst> engine) =>
+            engine = env.CreatePredictionEngine<TSrc, TDst>(transformer);
+
         /// <summary>
         /// Perform one prediction using the model.
         /// </summary>

src/Microsoft.ML.Api/Properties/AssemblyInfo.cs

@@ -0,0 +1,10 @@
+// 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.Runtime.CompilerServices;
+using Microsoft.ML;
+
+[assembly: InternalsVisibleTo(assemblyName: "Microsoft.ML.TimeSeries" + PublicKey.Value)]
+
+[assembly: WantsToBeBestFriends]

src/Microsoft.ML.Api/TypedCursor.cs

@@ -76,6 +76,7 @@ public interface ICursorable<TRow>
     /// Similarly to the 'DataView{T}, this class uses IL generation to create the 'poke' methods that
     /// write directly into the fields of the user-defined type.
     /// </summary>
+    [BestFriend]
     internal sealed class TypedCursorable<TRow> : ICursorable<TRow>
         where TRow : class
     {

src/Microsoft.ML.Data/DataView/CompositeRowToRowMapper.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using Microsoft.ML.Runtime.Internal.Utilities;
 
 namespace Microsoft.ML.Runtime.Data
@@ -18,6 +19,9 @@ public sealed class CompositeRowToRowMapper : IRowToRowMapper
         public Schema InputSchema { get; }
         public Schema Schema { get; }
 
+        [BestFriend]
+        internal IRowToRowMapper[] InnerMappers => _innerMappers;
+
         /// <summary>
         /// Out of a series of mappers, construct a seemingly unitary mapper that is able to apply them in sequence.
         /// </summary>
@@ -84,6 +88,7 @@ public IRow GetRow(IRow input, Func<int, bool> active, out Action disposer)
                     // We want the last disposer to be called first, so the order of the addition here is important.
                 }
             }
+
             return result;
         }