Remove ISchematized interface from the codebase. (#1759)

* Remove ISchematized interface from the codebase.

1. Remove ISchematized
2. For any class that requires a Schema, we add an Schema as its field
3. Rename Schema to OutputSchema in IRowToRowMapper

* Address comments

* Clean redundant Schema field and point Schema to OutputSchema

* Replace Schema in SingleValueRowMapper with OutputSchema

Author: wschin

src/Microsoft.ML.Api/PredictionEngine.cs

@@ -196,7 +196,7 @@ private protected PredictionEngineBase(IHostEnvironment env, ITransformer transf
         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 cursorable = TypedCursorable<TDst>.Create(env, new EmptyDataView(env, mapper.OutputSchema), ignoreMissingColumns, outputSchemaDefinition);
             var outputRowLocal = mapper.GetRow(_inputRow, col => true, out disposer);
             outputRow = cursorable.GetRow(outputRowLocal);
         }

src/Microsoft.ML.Api/StatefulFilterTransform.cs

@@ -98,7 +98,9 @@ private StatefulFilterTransform(IHostEnvironment env, StatefulFilterTransform<TS
 
         public bool CanShuffle { get { return false; } }
 
-        public Schema Schema => _bindings.Schema;
+        Schema IDataView.Schema => OutputSchema;
+
+        public Schema OutputSchema => _bindings.Schema;
 
         public long? GetRowCount()
         {

src/Microsoft.ML.Core/Data/IDataView.cs

@@ -60,22 +60,11 @@ public interface ISchema
         void GetMetadata<TValue>(string kind, int col, ref TValue value);
     }
 
-    /// <summary>
-    /// Base interface for schematized information. IDataView and IRowCursor both derive from this.
-    /// </summary>
-    public interface ISchematized
-    {
-        /// <summary>
-        /// Gets an instance of Schema.
-        /// </summary>
-        Schema Schema { get; }
-    }
-
     /// <summary>
     /// The input and output of Query Operators (Transforms). This is the fundamental data pipeline
     /// type, comparable to IEnumerable for LINQ.
     /// </summary>
-    public interface IDataView : ISchematized
+    public interface IDataView
     {
         /// <summary>
         /// Whether this IDataView supports shuffling of rows, to any degree.
@@ -124,6 +113,11 @@ public interface IDataView : ISchematized
         /// <returns></returns>
         IRowCursor[] GetRowCursorSet(out IRowCursorConsolidator consolidator,
             Func<int, bool> needCol, int n, Random rand = null);
+
+        /// <summary>
+        /// Gets an instance of Schema.
+        /// </summary>
+        Schema Schema { get; }
     }
 
     /// <summary>
@@ -148,7 +142,7 @@ public interface IRowCursorConsolidator
     /// A logical row. May be a row of an IDataView or a stand-alone row. If/when its contents
     /// change, its ICounted.Counter value is incremented.
     /// </summary>
-    public interface IRow : ISchematized, ICounted
+    public interface IRow : ICounted
     {
         /// <summary>
         /// Returns whether the given column is active in this row.
@@ -161,6 +155,13 @@ public interface IRow : ISchematized, ICounted
         /// <typeparamref name="TValue"/> differs from this column's type.
         /// </summary>
         ValueGetter<TValue> GetGetter<TValue>(int col);
+
+        /// <summary>
+        /// Gets a <see cref="Schema"/>, which provides name and type information for variables
+        /// (i.e., columns in ML.NET's type system) stored in this row.
+        /// </summary>
+        Schema Schema { get; }
+
     }
 
     /// <summary>

src/Microsoft.ML.Core/Data/ISchemaBindableMapper.cs

@@ -30,13 +30,18 @@ public interface ISchemaBindableMapper
     /// This interface is used to map a schema from input columns to output columns. The <see cref="ISchemaBoundMapper"/> should keep track
     /// of the input columns that are needed for the mapping.
     /// </summary>
-    public interface ISchemaBoundMapper : ISchematized
+    public interface ISchemaBoundMapper
     {
         /// <summary>
         /// The <see cref="RoleMappedSchema"/> that was passed to the <see cref="ISchemaBoundMapper"/> in the binding process.
         /// </summary>
         RoleMappedSchema InputRoleMappedSchema { get; }
 
+        /// <summary>
+        /// Gets schema of this mapper's output.
+        /// </summary>
+        Schema OutputSchema { get; }
+
         /// <summary>
         /// A property to get back the <see cref="ISchemaBindableMapper"/> that produced this <see cref="ISchemaBoundMapper"/>.
         /// </summary>
@@ -53,6 +58,11 @@ public interface ISchemaBoundMapper : ISchematized
     /// </summary>
     public interface ISchemaBoundRowMapper : ISchemaBoundMapper, IRowToRowMapper
     {
+        /// <summary>
+        /// There are two schemas from <see cref="ISchemaBoundMapper"/> and <see cref="IRowToRowMapper"/>.
+        /// Since the two parent schema's are identical in all derived classes, we merge them into <see cref="OutputSchema"/>.
+        /// </summary>
+        new Schema OutputSchema { get; }
     }
 
     /// <summary>
@@ -61,15 +71,20 @@ public interface ISchemaBoundRowMapper : ISchemaBoundMapper, IRowToRowMapper
     /// return a subset of the input columns.
     /// This interface is similar to <see cref="ISchemaBoundRowMapper"/>, except it does not have any input role mappings,
     /// so to rebind, the same input column names must be used.
-    /// Implementing of this object are typically created using a definie input <see cref="ISchema"/>.
+    /// Implementations of this interface are typically created over defined input <see cref="Schema"/>.
     /// </summary>
-    public interface IRowToRowMapper : ISchematized
+    public interface IRowToRowMapper
     {
         /// <summary>
         /// Mappers are defined as accepting inputs with this very specific schema.
         /// </summary>
         Schema InputSchema { get; }
 
+        /// <summary>
+        /// Gets an instance of <see cref="Schema"/> which describes the columns' names and types in the output generated by this mapper.
+        /// </summary>
+        Schema OutputSchema { get; }
+
         /// <summary>
         /// Given a predicate specifying which columns are needed, return a predicate indicating which input columns are
         /// needed. The domain of the function is defined over the indices of the columns of <see cref="ISchema.ColumnCount"/>
@@ -82,9 +97,9 @@ public interface IRowToRowMapper : ISchematized
         /// The active columns are those for which <paramref name="active"/> returns true. Getting values on inactive
         /// columns of the returned row will throw. Null predicates are disallowed.
         ///
-        /// The <see cref="ISchematized.Schema"/> of <paramref name="input"/> should be the same object as
+        /// The <see cref="IRow.Schema"/> of <paramref name="input"/> should be the same object as
         /// <see cref="InputSchema"/>. Implementors of this method should throw if that is not the case. Conversely,
-        /// the returned value must have the same schema as <see cref="ISchematized.Schema"/>.
+        /// the returned value must have the same schema as <see cref="OutputSchema"/>.
         ///
         /// This method creates a live connection between the input <see cref="IRow"/> and the output <see
         /// cref="IRow"/>. In particular, when the getters of the output <see cref="IRow"/> are invoked, they invoke the

src/Microsoft.ML.Core/Data/RoleMappedSchema.cs

@@ -467,7 +467,7 @@ public RoleMappedSchema(Schema schema, string label, string feature,
     /// <summary>
     /// Encapsulates an <see cref="IDataView"/> plus a corresponding <see cref="RoleMappedSchema"/>.
     /// Note that the schema of <see cref="RoleMappedSchema.Schema"/> of <see cref="Schema"/> is
-    /// guaranteed to equal the the <see cref="ISchematized.Schema"/> of <see cref="Data"/>.
+    /// guaranteed to equal the the <see cref="IDataView.Schema"/> of <see cref="Data"/>.
     /// </summary>
     public sealed class RoleMappedData
     {
@@ -478,7 +478,7 @@ public sealed class RoleMappedData
 
         /// <summary>
         /// The role mapped schema. Note that <see cref="Schema"/>'s <see cref="RoleMappedSchema.Schema"/> is
-        /// guaranteed to be the same as <see cref="Data"/>'s <see cref="ISchematized.Schema"/>.
+        /// guaranteed to be the same as <see cref="Data"/>'s <see cref="IDataView.Schema"/>.
         /// </summary>
         public RoleMappedSchema Schema { get; }
 

src/Microsoft.ML.Core/Data/Schema.cs

@@ -14,7 +14,7 @@
 namespace Microsoft.ML.Data
 {
     /// <summary>
-    /// This class represents the schema of an <see cref="ISchematized"/> object (like an <see cref="IDataView"/> or an <see cref="IRow"/>).
+    /// This class represents the <see cref="Schema"/> of an object like, for interstance, an <see cref="IDataView"/> or an <see cref="IRow"/>.
     /// On the high level, the schema is a collection of 'columns'. Each column has the following properties:
     /// - Column name.
     /// - Column type.

src/Microsoft.ML.Data/Commands/ScoreCommand.cs

@@ -306,8 +306,8 @@ public static TScorerFactory GetScorerComponent(
 
             ComponentCatalog.LoadableClassInfo info = null;
             ReadOnlyMemory<char> scoreKind = default;
-            if (mapper.Schema.Count > 0 &&
-                mapper.Schema.TryGetMetadata(TextType.Instance, MetadataUtils.Kinds.ScoreColumnKind, 0, ref scoreKind) &&
+            if (mapper.OutputSchema.Count > 0 &&
+                mapper.OutputSchema.TryGetMetadata(TextType.Instance, MetadataUtils.Kinds.ScoreColumnKind, 0, ref scoreKind) &&
                 !scoreKind.IsEmpty)
             {
                 var loadName = scoreKind.ToString();

src/Microsoft.ML.Data/Data/IRowSeekable.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 Microsoft.ML.Data;
 using System;
 
 namespace Microsoft.ML.Runtime.Data
@@ -11,9 +12,11 @@ namespace Microsoft.ML.Runtime.Data
     /// <summary>
     /// Represents a data view that supports random access to a specific row.
     /// </summary>
-    public interface IRowSeekable : ISchematized
+    public interface IRowSeekable
     {
         IRowSeeker GetSeeker(Func<int, bool> predicate);
+
+        Schema Schema { get; }
     }
 
     /// <summary>

src/Microsoft.ML.Data/Data/ITransposeDataView.cs

@@ -28,7 +28,7 @@ public interface ITransposeDataView : IDataView
         /// <summary>
         /// An enhanced schema, containing information on the transposition properties, if any,
         /// of each column. Note that there is no contract or suggestion that this property
-        /// should be equal to <see cref="ISchematized.Schema"/>.
+        /// should be equal to <see cref="IDataView.Schema"/>.
         /// </summary>
         ITransposeSchema TransposeSchema { get; }
 

src/Microsoft.ML.Data/DataLoadSave/TransformerChain.cs

@@ -227,7 +227,7 @@ public IRowToRowMapper GetRowToRowMapper(Schema inputSchema)
             for (int i = 0; i < mappers.Length; ++i)
             {
                 mappers[i] = _transformers[i].GetRowToRowMapper(schema);
-                schema = mappers[i].Schema;
+                schema = mappers[i].OutputSchema;
             }
             return new CompositeRowToRowMapper(inputSchema, mappers);
         }

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

@@ -18,7 +18,7 @@ public sealed class CompositeRowToRowMapper : IRowToRowMapper
         private static readonly IRowToRowMapper[] _empty = new IRowToRowMapper[0];
 
         public Schema InputSchema { get; }
-        public Schema Schema { get; }
+        public Schema OutputSchema { get; }
 
         /// <summary>
         /// Out of a series of mappers, construct a seemingly unitary mapper that is able to apply them in sequence.
@@ -32,7 +32,7 @@ public CompositeRowToRowMapper(Schema inputSchema, IRowToRowMapper[] mappers)
             Contracts.CheckValueOrNull(mappers);
             InnerMappers = Utils.Size(mappers) > 0 ? mappers : _empty;
             InputSchema = inputSchema;
-            Schema = Utils.Size(mappers) > 0 ? mappers[mappers.Length - 1].Schema : inputSchema;
+            OutputSchema = Utils.Size(mappers) > 0 ? mappers[mappers.Length - 1].OutputSchema : inputSchema;
         }
 
         public Func<int, bool> GetDependencies(Func<int, bool> predicate)

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

@@ -154,7 +154,7 @@ private sealed class RowCursor : LinkedRowFilterCursorBase
                 private T1 _src;
 
                 public RowCursor(Impl<T1, T2> parent, IRowCursor input, bool[] active)
-                    : base(parent.Host, input, parent.Schema, active)
+                    : base(parent.Host, input, parent.OutputSchema, active)
                 {
                     _getSrc = Input.GetGetter<T1>(parent._colSrc);
                     if (parent._conv == null)

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

@@ -75,7 +75,7 @@ private static VersionInfo GetVersionInfo()
                 loaderAssemblyName: typeof(RowToRowMapperTransform).Assembly.FullName);
         }
 
-        public override Schema Schema => _bindings.Schema;
+        public override Schema OutputSchema => _bindings.Schema;
 
         bool ICanSaveOnnx.CanSaveOnnx(OnnxContext ctx) => _mapper is ICanSaveOnnx onnxMapper ? onnxMapper.CanSaveOnnx(ctx) : false;
 
@@ -233,7 +233,7 @@ public Func<int, bool> GetDependencies(Func<int, bool> predicate)
             return predicateInput;
         }
 
-        Schema IRowToRowMapper.InputSchema => Source.Schema;
+        public Schema InputSchema => Source.Schema;
 
         public IRow GetRow(IRow input, Func<int, bool> active, out Action disposer)
         {
@@ -245,13 +245,13 @@ public IRow GetRow(IRow input, Func<int, bool> active, out Action disposer)
             using (var ch = Host.Start("GetEntireRow"))
             {
                 Action disp;
-                var activeArr = new bool[Schema.ColumnCount];
-                for (int i = 0; i < Schema.ColumnCount; i++)
+                var activeArr = new bool[OutputSchema.ColumnCount];
+                for (int i = 0; i < OutputSchema.ColumnCount; i++)
                     activeArr[i] = active(i);
                 var pred = GetActiveOutputColumns(activeArr);
                 var getters = _mapper.CreateGetters(input, pred, out disp);
                 disposer += disp;
-                return new Row(input, this, Schema, getters);
+                return new Row(input, this, OutputSchema, getters);
             }
         }
 

src/Microsoft.ML.Data/Dirty/ChooseColumnsByIndexTransform.cs

@@ -245,7 +245,7 @@ public override void Save(ModelSaveContext ctx)
             _bindings.Save(ctx);
         }
 
-        public override Schema Schema => _bindings.AsSchema;
+        public override Schema OutputSchema => _bindings.AsSchema;
 
         protected override bool? ShouldUseParallelCursors(Func<int, bool> predicate)
         {

src/Microsoft.ML.Data/EntryPoints/TransformModel.cs

@@ -193,6 +193,8 @@ private sealed class CompositeRowToRowMapper : IRowToRowMapper
 
             public Schema Schema => _chain.Schema;
 
+            public Schema OutputSchema => Schema;
+
             public CompositeRowToRowMapper(IExceptionContext ectx, IDataView chain, ISchema rootSchema)
             {
                 Contracts.CheckValue(ectx, nameof(ectx));

src/Microsoft.ML.Data/Evaluators/RankerEvaluator.cs

@@ -566,7 +566,16 @@ private static VersionInfo GetVersionInfo()
 
         public bool CanShuffle { get { return _transform.CanShuffle; } }
 
-        public Schema Schema => _transform.Schema;
+        /// <summary>
+        /// Explicit implementation prevents Schema from being accessed from derived classes.
+        /// It's our first step to separate data produced by transform from transform.
+        /// </summary>
+        Schema IDataView.Schema => OutputSchema;
+
+        /// <summary>
+        /// Shape information of the produced output. Note that the input and the output of this transform (and their types) are identical.
+        /// </summary>
+        public Schema OutputSchema => _transform.OutputSchema;
 
         public RankerPerInstanceTransform(IHostEnvironment env, IDataView input, string labelCol, string scoreCol, string groupCol,
                 int truncationLevel, Double[] labelGains)

src/Microsoft.ML.Data/Prediction/Calibrator.cs

@@ -528,7 +528,7 @@ private sealed class Bound : ISchemaBoundRowMapper
             public ISchemaBindableMapper Bindable => _parent;
             public RoleMappedSchema InputRoleMappedSchema => _predictor.InputRoleMappedSchema;
             public Schema InputSchema => _predictor.InputSchema;
-            public Schema Schema { get; }
+            public Schema OutputSchema { get; }
 
             public Bound(IHostEnvironment env, SchemaBindableCalibratedPredictor parent, RoleMappedSchema schema)
             {
@@ -537,16 +537,16 @@ public Bound(IHostEnvironment env, SchemaBindableCalibratedPredictor parent, Rol
                 _parent = parent;
                 _predictor = _parent._bindable.Bind(env, schema) as ISchemaBoundRowMapper;
                 env.Check(_predictor != null, "Predictor is not a row-to-row mapper");
-                if (!_predictor.Schema.TryGetColumnIndex(MetadataUtils.Const.ScoreValueKind.Score, out _scoreCol))
+                if (!_predictor.OutputSchema.TryGetColumnIndex(MetadataUtils.Const.ScoreValueKind.Score, out _scoreCol))
                     throw env.Except("Predictor does not output a score");
-                var scoreType = _predictor.Schema.GetColumnType(_scoreCol);
+                var scoreType = _predictor.OutputSchema.GetColumnType(_scoreCol);
                 env.Check(!scoreType.IsVector && scoreType.IsNumber);
-                Schema = Schema.Create(new BinaryClassifierSchema());
+                OutputSchema = Schema.Create(new BinaryClassifierSchema());
             }
 
             public Func<int, bool> GetDependencies(Func<int, bool> predicate)
             {
-                for (int i = 0; i < Schema.ColumnCount; i++)
+                for (int i = 0; i < OutputSchema.ColumnCount; i++)
                 {
                     if (predicate(i))
                         return _predictor.GetDependencies(col => true);
@@ -562,7 +562,7 @@ public Func<int, bool> GetDependencies(Func<int, bool> predicate)
             public IRow GetRow(IRow input, Func<int, bool> predicate, out Action disposer)
             {
                 Func<int, bool> predictorPredicate = col => false;
-                for (int i = 0; i < Schema.ColumnCount; i++)
+                for (int i = 0; i < OutputSchema.ColumnCount; i++)
                 {
                     if (predicate(i))
                     {
@@ -571,17 +571,17 @@ public IRow GetRow(IRow input, Func<int, bool> predicate, out Action disposer)
                     }
                 }
                 var predictorRow = _predictor.GetRow(input, predictorPredicate, out disposer);
-                var getters = new Delegate[Schema.ColumnCount];
-                for (int i = 0; i < Schema.ColumnCount - 1; i++)
+                var getters = new Delegate[OutputSchema.ColumnCount];
+                for (int i = 0; i < OutputSchema.ColumnCount - 1; i++)
                 {
                     var type = predictorRow.Schema.GetColumnType(i);
                     if (!predicate(i))
                         continue;
                     getters[i] = Utils.MarshalInvoke(GetPredictorGetter<int>, type.RawType, predictorRow, i);
                 }
-                if (predicate(Schema.ColumnCount - 1))
-                    getters[Schema.ColumnCount - 1] = GetProbGetter(predictorRow);
-                return new SimpleRow(Schema, predictorRow, getters);
+                if (predicate(OutputSchema.ColumnCount - 1))
+                    getters[OutputSchema.ColumnCount - 1] = GetProbGetter(predictorRow);
+                return new SimpleRow(OutputSchema, predictorRow, getters);
             }
 
             private Delegate GetPredictorGetter<T>(IRow input, int col)
@@ -728,7 +728,7 @@ private static bool NeedCalibration(IHostEnvironment env, IChannel ch, ICalibrat
 
             var bindable = ScoreUtils.GetSchemaBindableMapper(env, predictor);
             var bound = bindable.Bind(env, schema);
-            var outputSchema = bound.Schema;
+            var outputSchema = bound.OutputSchema;
             int scoreCol;
             if (!outputSchema.TryGetColumnIndex(MetadataUtils.Const.ScoreValueKind.Score, out scoreCol))
             {