ordered ---> useOrderedHashing

Author: wschin

src/Microsoft.ML.StaticPipe/TextStaticExtensions.cs

@@ -336,9 +336,9 @@ public OutPipelineColumn(Scalar<string> input,
                 int skipLength,
                 bool allLengths,
                 uint seed,
-                bool ordered,
+                bool useOrderedHashing,
                 int invertHash)
-                : base(new Reconciler(hashBits, ngramLength, skipLength, allLengths, seed, ordered, invertHash), input)
+                : base(new Reconciler(hashBits, ngramLength, skipLength, allLengths, seed, useOrderedHashing, invertHash), input)
             {
                 Input = input;
             }
@@ -351,17 +351,17 @@ private sealed class Reconciler : EstimatorReconciler, IEquatable<Reconciler>
             private readonly int _skipLength;
             private readonly bool _allLengths;
             private readonly uint _seed;
-            private readonly bool _ordered;
+            private readonly bool _useOrderedHashing;
             private readonly int _invertHash;
 
-            public Reconciler(int hashBits, int ngramLength, int skipLength, bool allLengths, uint seed, bool ordered, int invertHash)
+            public Reconciler(int hashBits, int ngramLength, int skipLength, bool allLengths, uint seed, bool useOrderedHashing, int invertHash)
             {
                 _hashBits = hashBits;
                 _ngramLength = ngramLength;
                 _skipLength = skipLength;
                 _allLengths = allLengths;
                 _seed = seed;
-                _ordered = ordered;
+                _useOrderedHashing = useOrderedHashing;
                 _invertHash = invertHash;
             }
 
@@ -372,7 +372,7 @@ public bool Equals(Reconciler other)
                     _skipLength == other._skipLength &&
                     _allLengths == other._allLengths &&
                     _seed == other._seed &&
-                    _ordered == other._ordered &&
+                    _useOrderedHashing == other._useOrderedHashing &&
                     _invertHash == other._invertHash;
             }
 
@@ -388,7 +388,7 @@ public override IEstimator<ITransformer> Reconcile(IHostEnvironment env,
                 foreach (var outCol in toOutput)
                     pairs.Add((outputNames[outCol], new[] { inputNames[((OutPipelineColumn)outCol).Input] }));
 
-                return new WordHashBagEstimator(env, pairs.ToArray(), _hashBits, _ngramLength, _skipLength, _allLengths, _seed, _ordered, _invertHash);
+                return new WordHashBagEstimator(env, pairs.ToArray(), _hashBits, _ngramLength, _skipLength, _allLengths, _seed, _useOrderedHashing, _invertHash);
             }
         }
 
@@ -402,7 +402,7 @@ public override IEstimator<ITransformer> Reconcile(IHostEnvironment env,
         /// <param name="skipLength">Maximum number of tokens to skip when constructing an ngram.</param>
         /// <param name="allLengths">Whether to include all ngram lengths up to <paramref name="ngramLength"/> or only <paramref name="ngramLength"/>.</param>
         /// <param name="seed">Hashing seed.</param>
-        /// <param name="ordered">Whether the position of each source column should be included in the hash (when there are multiple source columns).</param>
+        /// <param name="useOrderedHashing">Whether the position of each source column should be included in the hash (when there are multiple source columns).</param>
         /// <param name="invertHash">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.
         /// <paramref name="invertHash"/> specifies the upper bound of the number of distinct input values mapping to a hash that should be retained.
@@ -413,8 +413,8 @@ public static Vector<float> ProduceHashedWordBags(this Scalar<string> input,
             int skipLength = 0,
             bool allLengths = true,
             uint seed = 314489979,
-            bool ordered = true,
-            int invertHash = 0) => new OutPipelineColumn(input, numberOfBits, ngramLength, skipLength, allLengths, seed, ordered, invertHash);
+            bool useOrderedHashing = true,
+            int invertHash = 0) => new OutPipelineColumn(input, numberOfBits, ngramLength, skipLength, allLengths, seed, useOrderedHashing, invertHash);
     }
 
     /// <summary>
@@ -512,8 +512,8 @@ private sealed class OutPipelineColumn : Vector<float>
         {
             public readonly VarVector<Key<uint, string>> Input;
 
-            public OutPipelineColumn(VarVector<Key<uint, string>> input, int numberOfBits, int ngramLength, int skipLength, bool allLengths, uint seed, bool ordered, int invertHash)
-                : base(new Reconciler(numberOfBits, ngramLength, skipLength, allLengths, seed, ordered, invertHash), input)
+            public OutPipelineColumn(VarVector<Key<uint, string>> input, int numberOfBits, int ngramLength, int skipLength, bool allLengths, uint seed, bool useOrderedHashing, int invertHash)
+                : base(new Reconciler(numberOfBits, ngramLength, skipLength, allLengths, seed, useOrderedHashing, invertHash), input)
             {
                 Input = input;
             }
@@ -526,17 +526,17 @@ private sealed class Reconciler : EstimatorReconciler, IEquatable<Reconciler>
             private readonly int _skipLength;
             private readonly bool _allLengths;
             private readonly uint _seed;
-            private readonly bool _ordered;
+            private readonly bool _useOrderedHashing;
             private readonly int _invertHash;
 
-            public Reconciler(int numberOfBits, int ngramLength, int skipLength, bool allLengths, uint seed, bool ordered, int invertHash)
+            public Reconciler(int numberOfBits, int ngramLength, int skipLength, bool allLengths, uint seed, bool useOrderedHashing, int invertHash)
             {
                 _numberOfBits = numberOfBits;
                 _ngramLength = ngramLength;
                 _skipLength = skipLength;
                 _allLengths = allLengths;
                 _seed = seed;
-                _ordered = ordered;
+                _useOrderedHashing = useOrderedHashing;
                 _invertHash = invertHash;
             }
 
@@ -547,7 +547,7 @@ public bool Equals(Reconciler other)
                     _skipLength == other._skipLength &&
                     _allLengths == other._allLengths &&
                     _seed == other._seed &&
-                    _ordered == other._ordered &&
+                    _useOrderedHashing == other._useOrderedHashing &&
                     _invertHash == other._invertHash;
             }
 
@@ -561,7 +561,7 @@ public override IEstimator<ITransformer> Reconcile(IHostEnvironment env,
                 var columns = new List<NgramHashingEstimator.ColumnOptions>();
                 foreach (var outCol in toOutput)
                     columns.Add(new NgramHashingEstimator.ColumnOptions(outputNames[outCol], new[] { inputNames[((OutPipelineColumn)outCol).Input] },
-                          _ngramLength, _skipLength, _allLengths, _numberOfBits, _seed, _ordered, _invertHash));
+                          _ngramLength, _skipLength, _allLengths, _numberOfBits, _seed, _useOrderedHashing, _invertHash));
 
                 return new NgramHashingEstimator(env, columns.ToArray());
             }
@@ -580,7 +580,7 @@ public override IEstimator<ITransformer> Reconcile(IHostEnvironment env,
         /// <param name="skipLength">Maximum number of tokens to skip when constructing an ngram.</param>
         /// <param name="allLengths">Whether to include all ngram lengths up to <paramref name="ngramLength"/> or only <paramref name="ngramLength"/>.</param>
         /// <param name="seed">Hashing seed.</param>
-        /// <param name="ordered">Whether the position of each source column should be included in the hash (when there are multiple source columns).</param>
+        /// <param name="useOrderedHashing">Whether the position of each source column should be included in the hash (when there are multiple source columns).</param>
         /// <param name="invertHash">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.
         /// <paramref name="invertHash"/> specifies the upper bound of the number of distinct input values mapping to a hash that should be retained.
@@ -591,7 +591,7 @@ public static Vector<float> ProduceHashedNgrams(this VarVector<Key<uint, string>
             int skipLength = 0,
             bool allLengths = true,
             uint seed = 314489979,
-            bool ordered = true,
-            int invertHash = 0) => new OutPipelineColumn(input, numberOfBits, ngramLength, skipLength, allLengths, seed, ordered, invertHash);
+            bool useOrderedHashing = true,
+            int invertHash = 0) => new OutPipelineColumn(input, numberOfBits, ngramLength, skipLength, allLengths, seed, useOrderedHashing, invertHash);
     }
 }

src/Microsoft.ML.Transforms/Text/NgramHashingTransformer.cs

@@ -145,7 +145,7 @@ internal sealed class Options
             [Argument(ArgumentType.AtMostOnce,
                 HelpText = "Whether the position of each source column should be included in the hash (when there are multiple source columns).",
                 ShortName = "ord", SortOrder = 6)]
-            public bool Ordered = NgramHashingEstimator.Defaults.Ordered;
+            public bool Ordered = NgramHashingEstimator.Defaults.UseOrderedHashing;
 
             [Argument(ArgumentType.AtMostOnce, HelpText = "Limit the number of keys used to generate the slot name to this many. 0 means no invert hashing, -1 means no limit.",
                 ShortName = "ih")]
@@ -417,7 +417,7 @@ private NgramIdFinder GetNgramIdFinder(int iinfo)
                 uint mask = (1U << _parent._columns[iinfo].NumberOfBits) - 1;
                 int ngramLength = _parent._columns[iinfo].NgramLength;
                 bool rehash = _parent._columns[iinfo].RehashUnigrams;
-                bool ordered = _parent._columns[iinfo].Ordered;
+                bool ordered = _parent._columns[iinfo].UseOrderedHashing;
                 bool all = _parent._columns[iinfo].AllLengths;
                 uint seed = _parent._columns[iinfo].Seed;
 
@@ -891,7 +891,7 @@ public sealed class ColumnOptions
             /// <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;
+            public readonly bool UseOrderedHashing;
             /// <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.
@@ -916,7 +916,7 @@ public sealed class ColumnOptions
             /// <param name="allLengths">Whether to store all ngram lengths up to <paramref name="ngramLength"/>, or only <paramref name="ngramLength"/>.</param>
             /// <param name="numberOfBits">Number of bits to hash into. Must be between 1 and 31, inclusive.</param>
             /// <param name="seed">Hashing seed.</param>
-            /// <param name="ordered">Whether the position of each term should be included in the hash.</param>
+            /// <param name="useOrderedHashing">Whether the position of each term should be included in the hash.</param>
             /// <param name="invertHash">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.
@@ -930,7 +930,7 @@ public ColumnOptions(string name,
                 bool allLengths = NgramHashingEstimator.Defaults.AllLengths,
                 int numberOfBits = NgramHashingEstimator.Defaults.NumberOfBits,
                 uint seed = NgramHashingEstimator.Defaults.Seed,
-                bool ordered = NgramHashingEstimator.Defaults.Ordered,
+                bool useOrderedHashing = NgramHashingEstimator.Defaults.UseOrderedHashing,
                 int invertHash = NgramHashingEstimator.Defaults.InvertHash,
                 bool rehashUnigrams = NgramHashingEstimator.Defaults.RehashUnigrams)
             {
@@ -962,7 +962,7 @@ public ColumnOptions(string name,
                 AllLengths = allLengths;
                 NumberOfBits = numberOfBits;
                 Seed = seed;
-                Ordered = ordered;
+                UseOrderedHashing = useOrderedHashing;
                 InvertHash = invertHash;
                 RehashUnigrams = rehashUnigrams;
             }
@@ -996,7 +996,7 @@ internal ColumnOptions(ModelLoadContext ctx)
                 Contracts.CheckDecode(1 <= NumberOfBits && NumberOfBits <= 30);
                 Seed = ctx.Reader.ReadUInt32();
                 RehashUnigrams = ctx.Reader.ReadBoolByte();
-                Ordered = ctx.Reader.ReadBoolByte();
+                UseOrderedHashing = ctx.Reader.ReadBoolByte();
                 AllLengths = ctx.Reader.ReadBoolByte();
             }
 
@@ -1026,7 +1026,7 @@ internal ColumnOptions(ModelLoadContext ctx, string name, string[] inputColumnNa
                 Contracts.CheckDecode(1 <= NumberOfBits && NumberOfBits <= 30);
                 Seed = ctx.Reader.ReadUInt32();
                 RehashUnigrams = ctx.Reader.ReadBoolByte();
-                Ordered = ctx.Reader.ReadBoolByte();
+                UseOrderedHashing = ctx.Reader.ReadBoolByte();
                 AllLengths = ctx.Reader.ReadBoolByte();
             }
 
@@ -1060,7 +1060,7 @@ internal void Save(ModelSaveContext ctx)
                 ctx.Writer.Write(NumberOfBits);
                 ctx.Writer.Write(Seed);
                 ctx.Writer.WriteBoolByte(RehashUnigrams);
-                ctx.Writer.WriteBoolByte(Ordered);
+                ctx.Writer.WriteBoolByte(UseOrderedHashing);
                 ctx.Writer.WriteBoolByte(AllLengths);
             }
         }
@@ -1073,7 +1073,7 @@ internal static class Defaults
             internal const int NumberOfBits = 16;
             internal const uint Seed = 314489979;
             internal const bool RehashUnigrams = false;
-            internal const bool Ordered = true;
+            internal const bool UseOrderedHashing = true;
             internal const int InvertHash = 0;
         }
 
@@ -1095,7 +1095,7 @@ internal static class Defaults
         /// <param name="skipLength">Maximum number of tokens to skip when constructing an ngram.</param>
         /// <param name="allLengths">Whether to include all ngram lengths up to <paramref name="ngramLength"/> or only <paramref name="ngramLength"/>.</param>
         /// <param name="seed">Hashing seed.</param>
-        /// <param name="ordered">Whether the position of each source column should be included in the hash (when there are multiple source columns).</param>
+        /// <param name="useOrderedHashing">Whether the position of each source column should be included in the hash (when there are multiple source columns).</param>
         /// <param name="invertHash">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.
         /// <paramref name="invertHash"/> specifies the upper bound of the number of distinct input values mapping to a hash that should be retained.
@@ -1108,9 +1108,9 @@ internal NgramHashingEstimator(IHostEnvironment env,
             int skipLength = 0,
             bool allLengths = true,
             uint seed = 314489979,
-            bool ordered = true,
+            bool useOrderedHashing = true,
             int invertHash = 0)
-            : this(env, new ColumnOptions(outputColumnName, new[] { inputColumnName ?? outputColumnName }, ngramLength, skipLength, allLengths, numberOfBits, seed, ordered, invertHash))
+            : this(env, new ColumnOptions(outputColumnName, new[] { inputColumnName ?? outputColumnName }, ngramLength, skipLength, allLengths, numberOfBits, seed, useOrderedHashing, invertHash))
         {
         }