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);
         }