further cleaning and fix build with bestfriends assemblies

Author: artidoro

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

@@ -39,6 +39,10 @@
 [assembly: InternalsVisibleTo(assemblyName: "Microsoft.ML.TensorFlow" + PublicKey.Value)]
 [assembly: InternalsVisibleTo(assemblyName: "Microsoft.ML.TimeSeries" + PublicKey.Value)]
 [assembly: InternalsVisibleTo(assemblyName: "Microsoft.ML.Transforms" + PublicKey.Value)]
+[assembly: InternalsVisibleTo(assemblyName: "Microsoft.ML.DnnImageFeaturizer.AlexNet" + PublicKey.Value)]
+[assembly: InternalsVisibleTo(assemblyName: "Microsoft.ML.DnnImageFeaturizer.ResNet101" + PublicKey.Value)]
+[assembly: InternalsVisibleTo(assemblyName: "Microsoft.ML.DnnImageFeaturizer.ResNet18" + PublicKey.Value)]
+[assembly: InternalsVisibleTo(assemblyName: "Microsoft.ML.DnnImageFeaturizer.ResNet50" + PublicKey.Value)]
 
 [assembly: InternalsVisibleTo(assemblyName: "Microsoft.ML.StaticPipe" + PublicKey.Value)]
 

src/Microsoft.ML.Data/Transforms/ColumnCopying.cs

@@ -33,6 +33,9 @@
 
 namespace Microsoft.ML.Transforms
 {
+    /// <summary>
+    /// <see cref="ColumnCopyingEstimator"/> copies the input column to another column named as specified in the parameters of the transformation.
+    /// </summary>
     public sealed class ColumnCopyingEstimator : TrivialEstimator<ColumnCopyingTransformer>
     {
         [BestFriend]
@@ -41,6 +44,7 @@ internal ColumnCopyingEstimator(IHostEnvironment env, string outputColumnName, s
         {
         }
 
+        [BestFriend]
         internal ColumnCopyingEstimator(IHostEnvironment env, params (string outputColumnName, string inputColumnName)[] columns)
             : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(ColumnCopyingEstimator)), new ColumnCopyingTransformer(env, columns))
         {
@@ -74,6 +78,9 @@ public sealed class ColumnCopyingTransformer : OneToOneTransformerBase
         internal const string UserName = "Copy Columns Transform";
         internal const string ShortName = "Copy";
 
+        /// <summary>
+        /// Names of input and ouput column pairs on which the transformation is applied.
+        /// </summary>
         public IReadOnlyCollection<(string outputColumnName, string inputColumnName)> Columns => ColumnPairs.AsReadOnly();
 
         private static VersionInfo GetVersionInfo()

src/Microsoft.ML.Data/Transforms/Hashing.cs

@@ -1106,20 +1106,53 @@ public override void Process()
     }
 
     /// <summary>
-    /// Estimator for <see cref="HashingTransformer"/>
+    /// Estimator for <see cref="HashingTransformer"/> which can hash either single valued columns or vector columns. For vector columns,
+    /// it hashes each slot separately. It can hash either text values or key values.
     /// </summary>
     public sealed class HashingEstimator : IEstimator<HashingTransformer>
     {
         internal const int NumBitsMin = 1;
         internal const int NumBitsLim = 32;
 
+        internal static class Defaults
+        {
+            public const int HashBits = NumBitsLim - 1;
+            public const uint Seed = 314489979;
+            public const bool Ordered = false;
+            public const int InvertHash = 0;
+        }
+
+        /// <summary>
+        /// Describes how the transformer handles one column pair.
+        /// </summary>
         public sealed class ColumnInfo
         {
+            /// <summary>
+            /// Name of the column resulting from the transformation of <see cref="InputColumnName"/>.
+            /// </summary>
             public readonly string Name;
+            /// <summary>
+            /// Name of column to transform. If set to <see langword="null"/>, the value of the <see cref="Name"/> will be used as source.
+            /// </summary>
             public readonly string InputColumnName;
+            /// <summary>
+            /// Number of bits to hash into. Must be between 1 and 31, inclusive.
+            /// </summary>
             public readonly int HashBits;
+            /// <summary>
+            /// Hashing seed.
+            /// </summary>
             public readonly uint Seed;
+            /// <summary>
+            /// Whether the position of each term should be included in the hash.
+            /// </summary>
             public readonly bool Ordered;
+            /// <summary>
+            /// During hashing we constuct mappings between original values and the produced hash values.
+            /// Text representation of original values are stored in the slot names of the  metadata for the new column.Hashing, as such, can map many initial values to one.
+            /// <see cref="InvertHash"/> specifies the upper bound of the number of distinct input values mapping to a hash that should be retained.
+            /// <value>0</value> does not retain any input values. <value>-1</value> retains all input values mapping to each hash.
+            /// </summary>
             public readonly int InvertHash;
 
             /// <summary>
@@ -1136,10 +1169,10 @@ public sealed class ColumnInfo
             /// <value>0</value> does not retain any input values. <value>-1</value> retains all input values mapping to each hash.</param>
             public ColumnInfo(string name,
                 string inputColumnName = null,
-                int hashBits = HashingEstimator.Defaults.HashBits,
-                uint seed = HashingEstimator.Defaults.Seed,
-                bool ordered = HashingEstimator.Defaults.Ordered,
-                int invertHash = HashingEstimator.Defaults.InvertHash)
+                int hashBits = Defaults.HashBits,
+                uint seed = Defaults.Seed,
+                bool ordered = Defaults.Ordered,
+                int invertHash = Defaults.InvertHash)
             {
                 if (invertHash < -1)
                     throw Contracts.ExceptParam(nameof(invertHash), "Value too small, must be -1 or larger");
@@ -1183,14 +1216,6 @@ internal void Save(ModelSaveContext ctx)
             }
         }
 
-        public static class Defaults
-        {
-            public const int HashBits = NumBitsLim - 1;
-            public const uint Seed = 314489979;
-            public const bool Ordered = false;
-            public const int InvertHash = 0;
-        }
-
         private readonly IHost _host;
         private readonly ColumnInfo[] _columns;
 
@@ -1234,7 +1259,7 @@ internal HashingEstimator(IHostEnvironment env, params ColumnInfo[] columns)
         }
 
         /// <summary>
-        /// Train and return a transformer.
+        /// Trains and returns a <see cref="HashingTransformer"/>.
         /// </summary>
         public HashingTransformer Fit(IDataView input) => new HashingTransformer(_host, input, _columns);
 

src/Microsoft.ML.Data/Transforms/KeyToVector.cs

@@ -32,6 +32,9 @@
 
 namespace Microsoft.ML.Transforms.Conversions
 {
+    /// <summary>
+    /// Converts the key types back to their original vectors.
+    /// </summary>
     public sealed class KeyToVectorMappingTransformer : OneToOneTransformerBase
     {
         internal abstract class ColumnBase : OneToOneColumn
@@ -720,6 +723,9 @@ private bool SaveAsOnnxCore(OnnxContext ctx, int iinfo, ColInfo info, string src
         }
     }
 
+    /// <summary>
+    /// Estimator for <see cref="KeyToVectorMappingTransformer"/>. Converts the key types back to their original vectors.
+    /// </summary>
     public sealed class KeyToVectorMappingEstimator : TrivialEstimator<KeyToVectorMappingTransformer>
     {
         public static class Defaults
@@ -732,8 +738,17 @@ public static class Defaults
         /// </summary>
         public sealed class ColumnInfo
         {
+            /// <summary>
+            /// Name of the column resulting from the transformation of <cref see="InputColumnName"/>.
+            /// </summary>
             public readonly string Name;
+            /// <summary>
+            /// Name of column to transform. If set to <see langword="null"/>, the value of the <cref see="Name"/> will be used as source.
+            /// </summary>
             public readonly string InputColumnName;
+            /// <summary>
+            /// Whether to combine multiple indicator vectors into a single bag vector instead of concatenating them. This is only relevant when the input column is a vector.
+            /// </summary>
             public readonly bool Bag;
 
             /// <summary>

src/Microsoft.ML.Transforms/OneHotEncoding.cs

@@ -316,16 +316,16 @@ public static CommonOutputs.TransformOutput CatTransformDict(IHostEnvironment en
         }
 
         [TlcModule.EntryPoint(Name = "Transforms.CategoricalHashOneHotVectorizer",
-            Desc = OneHotHashEncoding.Summary,
-            UserName = OneHotHashEncoding.UserName)]
-        public static CommonOutputs.TransformOutput CatTransformHash(IHostEnvironment env, OneHotHashEncoding.Options input)
+            Desc = OneHotHashEncodingTransformer.Summary,
+            UserName = OneHotHashEncodingTransformer.UserName)]
+        public static CommonOutputs.TransformOutput CatTransformHash(IHostEnvironment env, OneHotHashEncodingTransformer.Options input)
         {
             Contracts.CheckValue(env, nameof(env));
             var host = env.Register("CatTransformDict");
             host.CheckValue(input, nameof(input));
             EntryPointUtils.CheckInputArgs(host, input);
 
-            var xf = OneHotHashEncoding.Create(host, input, input.Data);
+            var xf = OneHotHashEncodingTransformer.Create(host, input, input.Data);
             return new CommonOutputs.TransformOutput { Model = new TransformModelImpl(env, xf, input.Data), OutputData = xf };
         }
 

src/Microsoft.ML.Transforms/OneHotHashEncoding.cs

@@ -16,12 +16,15 @@
 using Microsoft.ML.Transforms.Categorical;
 using Microsoft.ML.Transforms.Conversions;
 
-[assembly: LoadableClass(OneHotHashEncoding.Summary, typeof(IDataTransform), typeof(OneHotHashEncoding), typeof(OneHotHashEncoding.Options), typeof(SignatureDataTransform),
-    OneHotHashEncoding.UserName, "CategoricalHashTransform", "CatHashTransform", "CategoricalHash", "CatHash")]
+[assembly: LoadableClass(OneHotHashEncodingTransformer.Summary, typeof(IDataTransform), typeof(OneHotHashEncodingTransformer), typeof(OneHotHashEncodingTransformer.Options), typeof(SignatureDataTransform),
+    OneHotHashEncodingTransformer.UserName, "CategoricalHashTransform", "CatHashTransform", "CategoricalHash", "CatHash")]
 
 namespace Microsoft.ML.Transforms.Categorical
 {
-    public sealed class OneHotHashEncoding : ITransformer, ICanSaveModel
+    /// <summary>
+    /// Produces a column of indicator vectors. The mapping between a value and a corresponding index is done through hashing.
+    /// </summary>
+    public sealed class OneHotHashEncodingTransformer : ITransformer, ICanSaveModel
     {
         internal sealed class Column : OneToOneColumn
         {
@@ -118,7 +121,7 @@ internal sealed class Options : TransformInputBase
         internal const string UserName = "Categorical Hash Transform";
 
         /// <summary>
-        /// A helper method to create <see cref="OneHotHashEncoding"/>.
+        /// A helper method to create <see cref="OneHotHashEncodingTransformer"/>.
         /// </summary>
         /// <param name="env">Host Environment.</param>
         /// <param name="input">Input <see cref="IDataView"/>. This is the output from previous transform or loader.</param>
@@ -167,31 +170,45 @@ internal static IDataTransform Create(IHostEnvironment env, Options options, IDa
 
         private readonly TransformerChain<ITransformer> _transformer;
 
-        internal OneHotHashEncoding(HashingEstimator hash, IEstimator<ITransformer> keyToVector, IDataView input)
+        internal OneHotHashEncodingTransformer(HashingEstimator hash, IEstimator<ITransformer> keyToVector, IDataView input)
         {
             if (keyToVector != null)
                 _transformer = hash.Append(keyToVector).Fit(input);
             else
                 _transformer = new TransformerChain<ITransformer>(hash.Fit(input));
         }
-
+        /// <summary>
+        /// Schema propagation for transformers. Returns the output schema of the data, if
+        /// the input schema is like the one provided.
+        /// </summary>
         public Schema GetOutputSchema(Schema inputSchema) => _transformer.GetOutputSchema(inputSchema);
 
+        /// <summary>
+        /// Take the data in, make transformations, output the data. Note that <see cref="IDataView"/>
+        /// are lazy, so no actual transformations happen here, just schema validation.
+        /// </summary>
         public IDataView Transform(IDataView input) => _transformer.Transform(input);
 
         public void Save(ModelSaveContext ctx) => _transformer.Save(ctx);
 
+        /// <summary>
+        /// Whether a call to <see cref="GetRowToRowMapper"/> should succeed, on an appropriate schema.
+        /// </summary>
         public bool IsRowToRowMapper => _transformer.IsRowToRowMapper;
 
+        /// <summary>
+        /// Constructs a row-to-row mapper based on an input schema.
+        /// </summary>
         public IRowToRowMapper GetRowToRowMapper(Schema inputSchema) => _transformer.GetRowToRowMapper(inputSchema);
     }
 
     /// <summary>
-    /// Estimator which takes set of columns and produce for each column indicator array. Use hashing to determine indicator position.
+    /// Estimator that produces a column of indicator vectors. The mapping between a value and a corresponding index is done through hashing.
     /// </summary>
-    public sealed class OneHotHashEncodingEstimator : IEstimator<OneHotHashEncoding>
+    public sealed class OneHotHashEncodingEstimator : IEstimator<OneHotHashEncodingTransformer>
     {
-        public static class Defaults
+        [BestFriend]
+        internal static class Defaults
         {
             public const int HashBits = 16;
             public const uint Seed = 314489979;
@@ -200,6 +217,9 @@ public static class Defaults
             public const OneHotEncodingTransformer.OutputKind OutputKind = OneHotEncodingTransformer.OutputKind.Bag;
         }
 
+        /// <summary>
+        /// Describes how the transformer handles one column pair.
+        /// </summary>
         public sealed class ColumnInfo
         {
             public readonly HashingEstimator.ColumnInfo HashInfo;
@@ -321,8 +341,8 @@ public SchemaShape GetOutputSchema(SchemaShape inputSchema)
         }
 
         /// <summary>
-        /// Train and return a transformer.
+        /// Trains and returns a <see cref="OneHotHashEncodingTransformer"/>.
         /// </summary>
-        public OneHotHashEncoding Fit(IDataView input) => new OneHotHashEncoding(_hash, _toSomething, input);
+        public OneHotHashEncodingTransformer Fit(IDataView input) => new OneHotHashEncodingTransformer(_hash, _toSomething, input);
     }
 }

test/Microsoft.ML.TestFramework/DataPipe/TestDataPipe.cs

@@ -1104,7 +1104,7 @@ private void TestHashTransformHelper<T>(T[] data, uint[] results, NumberType typ
             builder.AddColumn("F1", type, data);
             var srcView = builder.GetDataView();
 
-            var hashTransform = new HashingTransformer(Env, new HashingTransformer.ColumnInfo("F1", "F1", 5, 42)).Transform(srcView);
+            var hashTransform = new HashingTransformer(Env, new HashingEstimator.ColumnInfo("F1", "F1", 5, 42)).Transform(srcView);
             using (var cursor = hashTransform.GetRowCursorForAllColumns())
             {
                 var resultGetter = cursor.GetGetter<uint>(1);
@@ -1135,7 +1135,7 @@ private void TestHashTransformVectorHelper<T>(VBuffer<T> data, uint[][] results,
         private void TestHashTransformVectorHelper(ArrayDataViewBuilder builder, uint[][] results)
         {
             var srcView = builder.GetDataView();
-            var hashTransform = new HashingTransformer(Env, new HashingTransformer.ColumnInfo("F1V", "F1V", 5, 42)).Transform(srcView);
+            var hashTransform = new HashingTransformer(Env, new HashingEstimator.ColumnInfo("F1V", "F1V", 5, 42)).Transform(srcView);
             using (var cursor = hashTransform.GetRowCursorForAllColumns())
             {
                 var resultGetter = cursor.GetGetter<VBuffer<uint>>(1);