Rename termData to keyData per Ivan.

Author: TomFinley

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

@@ -112,15 +112,16 @@ public static ValueToKeyMappingEstimator MapValueToKey(this TransformsCatalog.Co
            => new ValueToKeyMappingEstimator(CatalogUtils.GetEnvironment(catalog), inputColumn, outputColumn, maxNumTerms, sort);
 
         /// <summary>
-        /// Converts value types into <see cref="KeyType"/>, optionally loading the keys to use from <paramref name="termData"/>.
+        /// Converts value types into <see cref="KeyType"/>, optionally loading the keys to use from <paramref name="keyData"/>.
         /// </summary>
         /// <param name="catalog">The categorical transform's catalog.</param>
         /// <param name="columns">The data columns to map to keys.</param>
-        /// <param name="termData">The data view containing the terms. If unspecified, they will be
-        /// determined from the input data upon fitting.</param>
+        /// <param name="keyData">The data view containing the terms. If specified, this should be a single column data
+        /// view, and the key-values will be taken from taht column. If unspecified, the key-values will be determined
+        /// from the input data upon fitting.</param>
         public static ValueToKeyMappingEstimator MapValueToKey(this TransformsCatalog.ConversionTransforms catalog,
-            ValueToKeyMappingTransformer.ColumnInfo[] columns, IDataView termData = null)
-            => new ValueToKeyMappingEstimator(CatalogUtils.GetEnvironment(catalog), columns, termData);
+            ValueToKeyMappingTransformer.ColumnInfo[] columns, IDataView keyData = null)
+            => new ValueToKeyMappingEstimator(CatalogUtils.GetEnvironment(catalog), columns, keyData);
 
         /// <summary>
         /// Maps specified keys to specified values

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

@@ -19,7 +19,7 @@ public static class Defaults
 
         private readonly IHost _host;
         private readonly ValueToKeyMappingTransformer.ColumnInfo[] _columns;
-        private readonly IDataView _termData;
+        private readonly IDataView _keyData;
 
         /// <summary>
         /// Initializes a new instance of <see cref="ValueToKeyMappingEstimator"/>.
@@ -35,24 +35,24 @@ public ValueToKeyMappingEstimator(IHostEnvironment env, string inputColumn, stri
         {
         }
 
-        public ValueToKeyMappingEstimator(IHostEnvironment env, ValueToKeyMappingTransformer.ColumnInfo[] columns, IDataView termData = null)
+        public ValueToKeyMappingEstimator(IHostEnvironment env, ValueToKeyMappingTransformer.ColumnInfo[] columns, IDataView keyData = null)
         {
             Contracts.CheckValue(env, nameof(env));
             _host = env.Register(nameof(ValueToKeyMappingEstimator));
             _host.CheckNonEmpty(columns, nameof(columns));
-            _host.CheckValueOrNull(termData);
-            if (termData != null && termData.Schema.Count != 1)
+            _host.CheckValueOrNull(keyData);
+            if (keyData != null && keyData.Schema.Count != 1)
             {
-                throw _host.ExceptParam(nameof(termData), "If specified, this data view should contain only a single column " +
-                    $"containing the terms to map, but this had {termData.Schema.Count} columns.");
+                throw _host.ExceptParam(nameof(keyData), "If specified, this data view should contain only a single column " +
+                    $"containing the terms to map, but this had {keyData.Schema.Count} columns.");
 
             }
 
             _columns = columns;
-            _termData = termData;
+            _keyData = keyData;
         }
 
-        public ValueToKeyMappingTransformer Fit(IDataView input) => new ValueToKeyMappingTransformer(_host, input, _columns, _termData, false);
+        public ValueToKeyMappingTransformer Fit(IDataView input) => new ValueToKeyMappingTransformer(_host, input, _columns, _keyData, false);
 
         public SchemaShape GetOutputSchema(SchemaShape inputSchema)
         {

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

@@ -294,13 +294,13 @@ internal ValueToKeyMappingTransformer(IHostEnvironment env, IDataView input,
         { }
 
         internal ValueToKeyMappingTransformer(IHostEnvironment env, IDataView input,
-            ColumnInfo[] columns, IDataView termData, bool autoConvert)
+            ColumnInfo[] columns, IDataView keyData, bool autoConvert)
             : base(Contracts.CheckRef(env, nameof(env)).Register(RegistrationName), GetColumnPairs(columns))
         {
             using (var ch = Host.Start("Training"))
             {
                 var infos = CreateInfos(input.Schema);
-                _unboundMaps = Train(Host, ch, infos, termData, columns, input, autoConvert);
+                _unboundMaps = Train(Host, ch, infos, keyData, columns, input, autoConvert);
                 _textMetadata = new bool[_unboundMaps.Length];
                 for (int iinfo = 0; iinfo < columns.Length; ++iinfo)
                     _textMetadata[iinfo] = columns[iinfo].TextKeyValues;
@@ -344,8 +344,8 @@ internal static IDataTransform Create(IHostEnvironment env, Arguments args, IDat
                         item.TextKeyValues ?? args.TextKeyValues);
                     cols[i].Terms = item.Terms ?? args.Terms;
                 };
-                var termData = GetTermDataViewOrNull(env, ch, args.DataFile, args.TermsColumn, args.Loader, out bool autoLoaded);
-                return new ValueToKeyMappingTransformer(env, input, cols, termData, autoLoaded).MakeDataTransform(input);
+                var keyData = GetKeyDataViewOrNull(env, ch, args.DataFile, args.TermsColumn, args.Loader, out bool autoLoaded);
+                return new ValueToKeyMappingTransformer(env, input, cols, keyData, autoLoaded).MakeDataTransform(input);
             }
         }
 
@@ -428,7 +428,7 @@ private static IRowMapper Create(IHostEnvironment env, ModelLoadContext ctx, Sch
         /// the term map. This will not be true in the case that the loader was adequately specified automatically.</param>
         /// <returns>The single-column data containing the term data from the file.</returns>
         [BestFriend]
-        internal static IDataView GetTermDataViewOrNull(IHostEnvironment env, IChannel ch,
+        internal static IDataView GetKeyDataViewOrNull(IHostEnvironment env, IChannel ch,
             string file, string termsColumn, IComponentFactory<IMultiStreamSource, IDataLoader> loaderFactory,
             out bool autoConvert)
         {
@@ -448,9 +448,9 @@ internal static IDataView GetTermDataViewOrNull(IHostEnvironment env, IChannel c
             string src = termsColumn;
             IMultiStreamSource fileSource = new MultiFileSource(file);
 
-            IDataView termData;
+            IDataView keyData;
             if (loaderFactory != null)
-                termData = loaderFactory.CreateComponent(env, fileSource);
+                keyData = loaderFactory.CreateComponent(env, fileSource);
             else
             {
                 // Determine the default loader from the extension.
@@ -463,11 +463,11 @@ internal static IDataView GetTermDataViewOrNull(IHostEnvironment env, IChannel c
                     ch.CheckUserArg(!string.IsNullOrWhiteSpace(src), nameof(termsColumn),
                         "Must be specified");
                     if (isBinary)
-                        termData = new BinaryLoader(env, new BinaryLoader.Arguments(), fileSource);
+                        keyData = new BinaryLoader(env, new BinaryLoader.Arguments(), fileSource);
                     else
                     {
                         ch.Assert(isTranspose);
-                        termData = new TransposeLoader(env, new TransposeLoader.Arguments(), fileSource);
+                        keyData = new TransposeLoader(env, new TransposeLoader.Arguments(), fileSource);
                     }
                 }
                 else
@@ -478,7 +478,7 @@ internal static IDataView GetTermDataViewOrNull(IHostEnvironment env, IChannel c
                             "{0} should not be specified when default loader is " + nameof(TextLoader) + ". Ignoring {0}={1}",
                             nameof(Arguments.TermsColumn), src);
                     }
-                    termData = new TextLoader(env,
+                    keyData = new TextLoader(env,
                         columns: new[] { new TextLoader.Column("Term", DataKind.TX, 0) },
                         dataSample: fileSource)
                         .Read(fileSource);
@@ -488,40 +488,40 @@ internal static IDataView GetTermDataViewOrNull(IHostEnvironment env, IChannel c
                 }
             }
             ch.AssertNonEmpty(src);
-            if (termData.Schema.GetColumnOrNull(src) == null)
+            if (keyData.Schema.GetColumnOrNull(src) == null)
                 throw ch.ExceptUserArg(nameof(termsColumn), "Unknown column '{0}'", src);
             // Now, remove everything but that one column.
             var selectTransformer = new ColumnSelectingTransformer(env, new string[] { src }, null);
-            termData = selectTransformer.Transform(termData);
-            ch.Assert(termData.Schema.Count == 1);
-            return termData;
+            keyData = selectTransformer.Transform(keyData);
+            ch.Assert(keyData.Schema.Count == 1);
+            return keyData;
         }
 
         /// <summary>
         /// Utility method to create the file-based <see cref="TermMap"/>.
         /// </summary>
-        private static TermMap CreateFileTermMap(IHostEnvironment env, IChannel ch, IDataView termData, bool autoConvert, Builder bldr)
+        private static TermMap CreateTermMapFromData(IHostEnvironment env, IChannel ch, IDataView keyData, bool autoConvert, Builder bldr)
         {
             Contracts.AssertValue(ch);
             ch.AssertValue(env);
-            ch.AssertValue(termData);
+            ch.AssertValue(keyData);
             ch.AssertValue(bldr);
-            if (termData.Schema.Count != 1)
+            if (keyData.Schema.Count != 1)
             {
-                throw ch.ExceptParam(nameof(termData), $"Input data containing terms should contain exactly one column, but " +
-                    $"had {termData.Schema.Count} instead. Consider using {nameof(ColumnSelectingEstimator)} on that data first.");
+                throw ch.ExceptParam(nameof(keyData), $"Input data containing terms should contain exactly one column, but " +
+                    $"had {keyData.Schema.Count} instead. Consider using {nameof(ColumnSelectingEstimator)} on that data first.");
             }
 
-            var typeSrc = termData.Schema[0].Type;
+            var typeSrc = keyData.Schema[0].Type;
             if (!autoConvert && !typeSrc.Equals(bldr.ItemType))
-                throw ch.ExceptUserArg(nameof(termData), "Input data's column must be of type '{0}' but was '{1}'", bldr.ItemType, typeSrc);
+                throw ch.ExceptUserArg(nameof(keyData), "Input data's column must be of type '{0}' but was '{1}'", bldr.ItemType, typeSrc);
 
-            using (var cursor = termData.GetRowCursor(termData.Schema[0]))
+            using (var cursor = keyData.GetRowCursor(keyData.Schema[0]))
             using (var pch = env.StartProgressChannel("Building dictionary from term data"))
             {
                 var header = new ProgressHeader(new[] { "Total Terms" }, new[] { "examples" });
                 var trainer = Trainer.Create(cursor, 0, autoConvert, int.MaxValue, bldr);
-                double rowCount = termData.GetRowCount() ?? double.NaN;
+                double rowCount = keyData.GetRowCount() ?? double.NaN;
                 long rowCur = 0;
                 pch.SetHeader(header,
                     e =>
@@ -544,12 +544,12 @@ private static TermMap CreateFileTermMap(IHostEnvironment env, IChannel ch, IDat
         /// This builds the <see cref="TermMap"/> instances per column.
         /// </summary>
         private static TermMap[] Train(IHostEnvironment env, IChannel ch, ColInfo[] infos,
-            IDataView termData, ColumnInfo[] columns, IDataView trainingData, bool autoConvert)
+            IDataView keyData, ColumnInfo[] columns, IDataView trainingData, bool autoConvert)
         {
             Contracts.AssertValue(env);
             env.AssertValue(ch);
             ch.AssertValue(infos);
-            ch.AssertValueOrNull(termData);
+            ch.AssertValueOrNull(keyData);
             ch.AssertValue(columns);
             ch.AssertValue(trainingData);
 
@@ -577,13 +577,13 @@ private static TermMap[] Train(IHostEnvironment env, IChannel ch, ColInfo[] info
                         bldr.ParseAddTermArg(termsArray, ch);
                     termMap[iinfo] = bldr.Finish();
                 }
-                else if (termData != null)
+                else if (keyData != null)
                 {
                     // First column using this file.
                     if (termsFromFile == null)
                     {
                         var bldr = Builder.Create(infos[iinfo].TypeSrc, columns[iinfo].Sort);
-                        termsFromFile = CreateFileTermMap(env, ch, termData, autoConvert, bldr);
+                        termsFromFile = CreateTermMapFromData(env, ch, keyData, autoConvert, bldr);
                     }
                     if (!termsFromFile.ItemType.Equals(infos[iinfo].TypeSrc.GetItemType()))
                     {
@@ -592,7 +592,7 @@ private static TermMap[] Train(IHostEnvironment env, IChannel ch, ColInfo[] info
                         // a complicated feature would be, and also because it's difficult to see how we
                         // can logically reconcile "reinterpretation" for different types with the resulting
                         // data view having an actual type.
-                        throw ch.ExceptParam(nameof(termData), "Terms from input data type '{0}' but mismatches column '{1}' item type '{2}'",
+                        throw ch.ExceptParam(nameof(keyData), "Terms from input data type '{0}' but mismatches column '{1}' item type '{2}'",
                             termsFromFile.ItemType, infos[iinfo].Name, infos[iinfo].TypeSrc.GetItemType());
                     }
                     termMap[iinfo] = termsFromFile;

src/Microsoft.ML.Transforms/OneHotEncoding.cs

@@ -139,14 +139,14 @@ internal static IDataTransform Create(IHostEnvironment env, Arguments args, IDat
                 col.SetTerms(column.Terms ?? args.Terms);
                 columns.Add(col);
             }
-            IDataView termData = null;
+            IDataView keyData = null;
             if (!string.IsNullOrEmpty(args.DataFile))
             {
                 using (var ch = h.Start("Load term data"))
-                    termData = ValueToKeyMappingTransformer.GetTermDataViewOrNull(env, ch, args.DataFile, args.TermsColumn, args.Loader, out bool autoLoaded);
-                h.AssertValue(termData);
+                    keyData = ValueToKeyMappingTransformer.GetKeyDataViewOrNull(env, ch, args.DataFile, args.TermsColumn, args.Loader, out bool autoLoaded);
+                h.AssertValue(keyData);
             }
-            var transformed = new OneHotEncodingEstimator(env, columns.ToArray(), termData).Fit(input).Transform(input);
+            var transformed = new OneHotEncodingEstimator(env, columns.ToArray(), keyData).Fit(input).Transform(input);
             return (IDataTransform)transformed;
         }
 
@@ -228,11 +228,11 @@ public OneHotEncodingEstimator(IHostEnvironment env, string inputColumn,
         {
         }
 
-        public OneHotEncodingEstimator(IHostEnvironment env, ColumnInfo[] columns, IDataView termData = null)
+        public OneHotEncodingEstimator(IHostEnvironment env, ColumnInfo[] columns, IDataView keyData = null)
         {
             Contracts.CheckValue(env, nameof(env));
             _host = env.Register(nameof(OneHotEncodingEstimator));
-            _term = new ValueToKeyMappingEstimator(_host, columns, termData);
+            _term = new ValueToKeyMappingEstimator(_host, columns, keyData);
             var binaryCols = new List<(string input, string output)>();
             var cols = new List<(string input, string output, bool bag)>();
             for (int i = 0; i < columns.Length; i++)