Rename Rff entirely

wschin · wschin · commit df08e28b3777 · 2019-03-06T16:48:53.000-08:00
diff --git a/docs/samples/Microsoft.ML.Samples/Dynamic/ProjectionTransforms.cs b/docs/samples/Microsoft.ML.Samples/Dynamic/ProjectionTransforms.cs
@@ -37,7 +37,7 @@ public static void Example()
             };
 
             // A pipeline to project Features column into Random fourier space.
-            var rffPipeline = ml.Transforms.KernelExpansion.CreateRandomFourierFeatures(nameof(SamplesUtils.DatasetUtils.SampleVectorOfNumbersData.Features), dimension: 4);
+            var rffPipeline = ml.Transforms.KernelExpansion.RandomFourierExpand(nameof(SamplesUtils.DatasetUtils.SampleVectorOfNumbersData.Features), dimension: 4);
             // The transformed (projected) data.
             var transformedData = rffPipeline.Fit(trainData).Transform(trainData);
             // Getting the data of the newly created column, so we can preview it.
diff --git a/src/Microsoft.ML.StaticPipe/TransformsStatic.cs b/src/Microsoft.ML.StaticPipe/TransformsStatic.cs
@@ -1591,13 +1591,13 @@ private sealed class Reconciler : EstimatorReconciler
             public override IEstimator<ITransformer> Reconcile(IHostEnvironment env, PipelineColumn[] toOutput,
                 IReadOnlyDictionary<PipelineColumn, string> inputNames, IReadOnlyDictionary<PipelineColumn, string> outputNames, IReadOnlyCollection<string> usedNames)
             {
-                var infos = new RandomFourierFeaturizingEstimator.ColumnOptions[toOutput.Length];
+                var infos = new RandomFourierExpansionEstimator.ColumnOptions[toOutput.Length];
                 for (int i = 0; i < toOutput.Length; ++i)
                 {
                     var tcol = (IColInput)toOutput[i];
-                    infos[i] = new RandomFourierFeaturizingEstimator.ColumnOptions(outputNames[toOutput[i]], tcol.Config.Dimension, tcol.Config.UseCosAndSinBases, inputNames[tcol.Input], tcol.Config.Generator, tcol.Config.Seed);
+                    infos[i] = new RandomFourierExpansionEstimator.ColumnOptions(outputNames[toOutput[i]], tcol.Config.Dimension, tcol.Config.UseCosAndSinBases, inputNames[tcol.Input], tcol.Config.Generator, tcol.Config.Seed);
                 }
-                return new RandomFourierFeaturizingEstimator(env, infos);
+                return new RandomFourierExpansionEstimator(env, infos);
             }
         }
 
@@ -1613,7 +1613,7 @@ public override IEstimator<ITransformer> Reconcile(IHostEnvironment env, Pipelin
         /// <param name="generator">Which kernel to use. (if it is null, <see cref="GaussianKernel"/> is used.)</param>
         /// <param name="seed">The seed of the random number generator for generating the new features. If not specified global random would be used.</param>
         public static Vector<float> LowerVectorSizeWithRandomFourierTransformation(this Vector<float> input,
-            int dimension = RandomFourierFeaturizingEstimator.Defaults.Dimension, bool useCosAndSinBases = RandomFourierFeaturizingEstimator.Defaults.UseCosAndSinBases,
+            int dimension = RandomFourierExpansionEstimator.Defaults.Dimension, bool useCosAndSinBases = RandomFourierExpansionEstimator.Defaults.UseCosAndSinBases,
             KernelBase generator = null, int? seed = null)
         {
             Contracts.CheckValue(input, nameof(input));
diff --git a/src/Microsoft.ML.Transforms/FourierDistributionSampler.cs b/src/Microsoft.ML.Transforms/FourierDistributionSampler.cs
@@ -33,8 +33,8 @@ namespace Microsoft.ML.Transforms
     internal delegate void SignatureKernelBase();
 
     /// <summary>
-    /// This class indicates which kernel should be approximated by the <see cref="RandomFourierFeaturizingTransformer"/>.
-    /// <seealso cref="RandomFourierFeaturizingEstimator"/>.
+    /// This class indicates which kernel should be approximated by the <see cref="RandomFourierExpansionTransformer"/>.
+    /// <seealso cref="RandomFourierExpansionEstimator"/>.
     /// </summary>
     public abstract class KernelBase
     {
diff --git a/src/Microsoft.ML.Transforms/KernelCatalog.cs b/src/Microsoft.ML.Transforms/KernelCatalog.cs
@@ -27,19 +27,19 @@ public static class KernelExpansionCatalog
         /// ]]>
         /// </format>
         /// </example>
-        public static RandomFourierFeaturizingEstimator CreateRandomFourierFeatures(this TransformsCatalog.KernelExpansionTransforms catalog,
+        public static RandomFourierExpansionEstimator RandomFourierExpand(this TransformsCatalog.KernelExpansionTransforms catalog,
             string outputColumnName,
             string inputColumnName = null,
-            int dimension = RandomFourierFeaturizingEstimator.Defaults.Dimension,
-            bool useCosAndSinBases = RandomFourierFeaturizingEstimator.Defaults.UseCosAndSinBases)
-            => new RandomFourierFeaturizingEstimator(CatalogUtils.GetEnvironment(catalog), outputColumnName, inputColumnName, dimension, useCosAndSinBases);
+            int dimension = RandomFourierExpansionEstimator.Defaults.Dimension,
+            bool useCosAndSinBases = RandomFourierExpansionEstimator.Defaults.UseCosAndSinBases)
+            => new RandomFourierExpansionEstimator(CatalogUtils.GetEnvironment(catalog), outputColumnName, inputColumnName, dimension, useCosAndSinBases);
 
         /// <summary>
         /// Takes columns filled with a vector of floats and maps its to a random low-dimensional feature space.
         /// </summary>
         /// <param name="catalog">The transform's catalog.</param>
         /// <param name="columns">The input columns to use for the transformation.</param>
-        public static RandomFourierFeaturizingEstimator CreateRandomFourierFeatures(this TransformsCatalog.KernelExpansionTransforms catalog, params RandomFourierFeaturizingEstimator.ColumnOptions[] columns)
-            => new RandomFourierFeaturizingEstimator(CatalogUtils.GetEnvironment(catalog), columns);
+        public static RandomFourierExpansionEstimator RandomFourierExpand(this TransformsCatalog.KernelExpansionTransforms catalog, params RandomFourierExpansionEstimator.ColumnOptions[] columns)
+            => new RandomFourierExpansionEstimator(CatalogUtils.GetEnvironment(catalog), columns);
     }
 }
diff --git a/src/Microsoft.ML.Transforms/RandomFourierFeaturizing.cs b/src/Microsoft.ML.Transforms/RandomFourierFeaturizing.cs
@@ -15,17 +15,17 @@
 using Microsoft.ML.Model;
 using Microsoft.ML.Transforms;
 
-[assembly: LoadableClass(RandomFourierFeaturizingTransformer.Summary, typeof(IDataTransform), typeof(RandomFourierFeaturizingTransformer), typeof(RandomFourierFeaturizingTransformer.Options), typeof(SignatureDataTransform),
+[assembly: LoadableClass(RandomFourierExpansionTransformer.Summary, typeof(IDataTransform), typeof(RandomFourierExpansionTransformer), typeof(RandomFourierExpansionTransformer.Options), typeof(SignatureDataTransform),
     "Random Fourier Features Transform", "RffTransform", "Rff")]
 
-[assembly: LoadableClass(RandomFourierFeaturizingTransformer.Summary, typeof(IDataTransform), typeof(RandomFourierFeaturizingTransformer), null, typeof(SignatureLoadDataTransform),
-    "Random Fourier Features Transform", RandomFourierFeaturizingTransformer.LoaderSignature)]
+[assembly: LoadableClass(RandomFourierExpansionTransformer.Summary, typeof(IDataTransform), typeof(RandomFourierExpansionTransformer), null, typeof(SignatureLoadDataTransform),
+    "Random Fourier Features Transform", RandomFourierExpansionTransformer.LoaderSignature)]
 
-[assembly: LoadableClass(RandomFourierFeaturizingTransformer.Summary, typeof(RandomFourierFeaturizingTransformer), null, typeof(SignatureLoadModel),
-    "Random Fourier Features Transform", RandomFourierFeaturizingTransformer.LoaderSignature)]
+[assembly: LoadableClass(RandomFourierExpansionTransformer.Summary, typeof(RandomFourierExpansionTransformer), null, typeof(SignatureLoadModel),
+    "Random Fourier Features Transform", RandomFourierExpansionTransformer.LoaderSignature)]
 
-[assembly: LoadableClass(typeof(IRowMapper), typeof(RandomFourierFeaturizingTransformer), null, typeof(SignatureLoadRowMapper),
-    "Random Fourier Features Transform", RandomFourierFeaturizingTransformer.LoaderSignature)]
+[assembly: LoadableClass(typeof(IRowMapper), typeof(RandomFourierExpansionTransformer), null, typeof(SignatureLoadRowMapper),
+    "Random Fourier Features Transform", RandomFourierExpansionTransformer.LoaderSignature)]
 
 namespace Microsoft.ML.Transforms
 {
@@ -36,21 +36,21 @@ namespace Microsoft.ML.Transforms
     /// This transformation is based on this paper by
     /// <a href="http://pages.cs.wisc.edu/~brecht/papers/07.rah.rec.nips.pdf">Rahimi and Recht</a>.
     /// </summary>
-    public sealed class RandomFourierFeaturizingTransformer : OneToOneTransformerBase
+    public sealed class RandomFourierExpansionTransformer : OneToOneTransformerBase
     {
         internal sealed class Options
         {
             [Argument(ArgumentType.Multiple | ArgumentType.Required, HelpText = "New column definition(s) (optional form: name:src)", Name = "Column", ShortName = "col", SortOrder = 1)]
             public Column[] Columns;
 
             [Argument(ArgumentType.AtMostOnce, HelpText = "The number of random Fourier features to create", ShortName = "dim")]
-            public int NewDim = RandomFourierFeaturizingEstimator.Defaults.Dimension;
+            public int NewDim = RandomFourierExpansionEstimator.Defaults.Dimension;
 
             [Argument(ArgumentType.Multiple, HelpText = "Which kernel to use?", ShortName = "kernel", SignatureType = typeof(SignatureKernelBase))]
             public IComponentFactory<KernelBase> MatrixGenerator = new GaussianKernel.Options();
 
             [Argument(ArgumentType.AtMostOnce, HelpText = "Create two features for every random Fourier frequency? (one for cos and one for sin)")]
-            public bool UseSin = RandomFourierFeaturizingEstimator.Defaults.UseCosAndSinBases;
+            public bool UseSin = RandomFourierExpansionEstimator.Defaults.UseCosAndSinBases;
 
             [Argument(ArgumentType.LastOccurenceWins,
                 HelpText = "The seed of the random number generator for generating the new features (if unspecified, " +
@@ -109,7 +109,7 @@ private sealed class TransformInfo
             private readonly TauswortheHybrid _rand;
             private readonly TauswortheHybrid.State _state;
 
-            public TransformInfo(IHost host, RandomFourierFeaturizingEstimator.ColumnOptions column, int d, float avgDist)
+            public TransformInfo(IHost host, RandomFourierExpansionEstimator.ColumnOptions column, int d, float avgDist)
             {
                 Contracts.AssertValue(host);
 
@@ -224,7 +224,7 @@ private static VersionInfo GetVersionInfo()
                 verReadableCur: 0x00010002,
                 verWeCanReadBack: 0x00010001,
                 loaderSignature: LoaderSignature,
-                loaderAssemblyName: typeof(RandomFourierFeaturizingTransformer).Assembly.FullName);
+                loaderAssemblyName: typeof(RandomFourierExpansionTransformer).Assembly.FullName);
         }
 
         private readonly TransformInfo[] _transformInfos;
@@ -238,7 +238,7 @@ private static string TestColumnType(DataViewType type)
             return "Expected vector of floats with known size";
         }
 
-        private static (string outputColumnName, string inputColumnName)[] GetColumnPairs(RandomFourierFeaturizingEstimator.ColumnOptions[] columns)
+        private static (string outputColumnName, string inputColumnName)[] GetColumnPairs(RandomFourierExpansionEstimator.ColumnOptions[] columns)
         {
             Contracts.CheckValue(columns, nameof(columns));
             return columns.Select(x => (x.Name, x.InputColumnName)).ToArray();
@@ -255,8 +255,8 @@ private protected override void CheckInputColumn(DataViewSchema inputSchema, int
                     new VectorType(NumberDataViewType.Single, _transformInfos[col].SrcDim).ToString(), type.ToString());
         }
 
-        internal RandomFourierFeaturizingTransformer(IHostEnvironment env, IDataView input, RandomFourierFeaturizingEstimator.ColumnOptions[] columns)
-            : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(RandomFourierFeaturizingTransformer)), GetColumnPairs(columns))
+        internal RandomFourierExpansionTransformer(IHostEnvironment env, IDataView input, RandomFourierExpansionEstimator.ColumnOptions[] columns)
+            : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(RandomFourierExpansionTransformer)), GetColumnPairs(columns))
         {
             var avgDistances = GetAvgDistances(columns, input);
             _transformInfos = new TransformInfo[columns.Length];
@@ -281,7 +281,7 @@ private static int RoundUp(int cflt, int cfltAlign)
             return cblob * cfltAlign;
         }
 
-        private float[] GetAvgDistances(RandomFourierFeaturizingEstimator.ColumnOptions[] columns, IDataView input)
+        private float[] GetAvgDistances(RandomFourierExpansionEstimator.ColumnOptions[] columns, IDataView input)
         {
             var avgDistances = new float[columns.Length];
             const int reservoirSize = 5000;
@@ -395,7 +395,7 @@ private static IDataTransform Create(IHostEnvironment env, ModelLoadContext ctx,
         private static IRowMapper Create(IHostEnvironment env, ModelLoadContext ctx, DataViewSchema inputSchema)
             => Create(env, ctx).MakeRowMapper(inputSchema);
 
-        private RandomFourierFeaturizingTransformer(IHost host, ModelLoadContext ctx)
+        private RandomFourierExpansionTransformer(IHost host, ModelLoadContext ctx)
          : base(host, ctx)
         {
             // *** Binary format ***
@@ -420,14 +420,14 @@ private static IDataTransform Create(IHostEnvironment env, Options options, IDat
             env.CheckValue(input, nameof(input));
 
             env.CheckValue(options.Columns, nameof(options.Columns));
-            var cols = new RandomFourierFeaturizingEstimator.ColumnOptions[options.Columns.Length];
+            var cols = new RandomFourierExpansionEstimator.ColumnOptions[options.Columns.Length];
             using (var ch = env.Start("ValidateArgs"))
             {
 
                 for (int i = 0; i < cols.Length; i++)
                 {
                     var item = options.Columns[i];
-                    cols[i] = new RandomFourierFeaturizingEstimator.ColumnOptions(
+                    cols[i] = new RandomFourierExpansionEstimator.ColumnOptions(
                         item.Name,
                         item.NewDim ?? options.NewDim,
                         item.UseSin ?? options.UseSin,
@@ -436,14 +436,14 @@ private static IDataTransform Create(IHostEnvironment env, Options options, IDat
                         item.Seed ?? options.Seed);
                 };
             }
-            return new RandomFourierFeaturizingTransformer(env, input, cols).MakeDataTransform(input);
+            return new RandomFourierExpansionTransformer(env, input, cols).MakeDataTransform(input);
         }
 
         // Factory method for SignatureLoadModel.
-        private static RandomFourierFeaturizingTransformer Create(IHostEnvironment env, ModelLoadContext ctx)
+        private static RandomFourierExpansionTransformer Create(IHostEnvironment env, ModelLoadContext ctx)
         {
             Contracts.CheckValue(env, nameof(env));
-            var host = env.Register(nameof(RandomFourierFeaturizingTransformer));
+            var host = env.Register(nameof(RandomFourierExpansionTransformer));
 
             host.CheckValue(ctx, nameof(ctx));
             ctx.CheckAtModel(GetVersionInfo());
@@ -452,7 +452,7 @@ private static RandomFourierFeaturizingTransformer Create(IHostEnvironment env,
                 int cbFloat = ctx.Reader.ReadInt32();
                 env.CheckDecode(cbFloat == sizeof(float));
             }
-            return new RandomFourierFeaturizingTransformer(host, ctx);
+            return new RandomFourierExpansionTransformer(host, ctx);
         }
 
         private protected override void SaveModel(ModelSaveContext ctx)
@@ -476,9 +476,9 @@ private sealed class Mapper : OneToOneMapperBase
             private readonly DataViewType[] _srcTypes;
             private readonly int[] _srcCols;
             private readonly DataViewType[] _types;
-            private readonly RandomFourierFeaturizingTransformer _parent;
+            private readonly RandomFourierExpansionTransformer _parent;
 
-            public Mapper(RandomFourierFeaturizingTransformer parent, DataViewSchema inputSchema)
+            public Mapper(RandomFourierExpansionTransformer parent, DataViewSchema inputSchema)
                : base(parent.Host.Register(nameof(Mapper)), parent, inputSchema)
             {
                 _parent = parent;
@@ -606,7 +606,7 @@ private void TransformFeatures(in VBuffer<float> src, ref VBuffer<float> dst, Tr
     /// <summary>
     /// Maps vector columns to a low -dimensional feature space.
     /// </summary>
-    public sealed class RandomFourierFeaturizingEstimator : IEstimator<RandomFourierFeaturizingTransformer>
+    public sealed class RandomFourierExpansionEstimator : IEstimator<RandomFourierExpansionTransformer>
     {
         [BestFriend]
         internal static class Defaults
@@ -679,22 +679,22 @@ public ColumnOptions(string name, int dimension, bool useCosAndSinBases, string
         /// <param name="inputColumnName">Name of the column to transform. If set to <see langword="null"/>, the value of the <paramref name="outputColumnName"/> will be used as source.</param>
         /// <param name="newDim">The number of random Fourier features to create.</param>
         /// <param name="useSin">Create two features for every random Fourier frequency? (one for cos and one for sin).</param>
-        internal RandomFourierFeaturizingEstimator(IHostEnvironment env, string outputColumnName, string inputColumnName = null, int newDim = Defaults.Dimension, bool useSin = Defaults.UseCosAndSinBases)
+        internal RandomFourierExpansionEstimator(IHostEnvironment env, string outputColumnName, string inputColumnName = null, int newDim = Defaults.Dimension, bool useSin = Defaults.UseCosAndSinBases)
             : this(env, new ColumnOptions(outputColumnName, newDim, useSin, inputColumnName ?? outputColumnName))
         {
         }
 
-        internal RandomFourierFeaturizingEstimator(IHostEnvironment env, params ColumnOptions[] columns)
+        internal RandomFourierExpansionEstimator(IHostEnvironment env, params ColumnOptions[] columns)
         {
             Contracts.CheckValue(env, nameof(env));
-            _host = env.Register(nameof(RandomFourierFeaturizingEstimator));
+            _host = env.Register(nameof(RandomFourierExpansionEstimator));
             _columns = columns;
         }
 
         /// <summary>
-        /// Trains and returns a <see cref="RandomFourierFeaturizingTransformer"/>.
+        /// Trains and returns a <see cref="RandomFourierExpansionTransformer"/>.
         /// </summary>
-        public RandomFourierFeaturizingTransformer Fit(IDataView input) => new RandomFourierFeaturizingTransformer(_host, input, _columns);
+        public RandomFourierExpansionTransformer Fit(IDataView input) => new RandomFourierExpansionTransformer(_host, input, _columns);
 
         /// <summary>
         /// Returns the <see cref="SchemaShape"/> of the schema which will be produced by the transformer.
diff --git a/test/Microsoft.ML.Benchmarks/RffTransform.cs b/test/Microsoft.ML.Benchmarks/RffTransform.cs
@@ -43,7 +43,7 @@ public void CV_Multiclass_Digits_RffTransform_OVAAveragedPerceptron()
 
             var data = loader.Load(_dataPath_Digits);
 
-            var pipeline = mlContext.Transforms.KernelExpansion.CreateRandomFourierFeatures("FeaturesRFF", "Features")
+            var pipeline = mlContext.Transforms.KernelExpansion.RandomFourierExpand("FeaturesRFF", "Features")
             .AppendCacheCheckpoint(mlContext)
             .Append(mlContext.Transforms.Concatenate("Features", "FeaturesRFF"))
             .Append(new ValueToKeyMappingEstimator(mlContext, "Label"))
diff --git a/test/Microsoft.ML.Core.Tests/UnitTests/TestEntryPoints.cs b/test/Microsoft.ML.Core.Tests/UnitTests/TestEntryPoints.cs
diff --git a/test/Microsoft.ML.Tests/Transformers/RffTests.cs b/test/Microsoft.ML.Tests/Transformers/RffTests.cs

Original file line number	Diff line number	Diff line change
`@@ -1591,13 +1591,13 @@ private sealed class Reconciler : EstimatorReconciler`
`1591`	`1591`	`public override IEstimator<ITransformer> Reconcile(IHostEnvironment env, PipelineColumn[] toOutput,`
`1592`	`1592`	`IReadOnlyDictionary<PipelineColumn, string> inputNames, IReadOnlyDictionary<PipelineColumn, string> outputNames, IReadOnlyCollection<string> usedNames)`
`1593`	`1593`	`{`
`1594`		`- var infos = new RandomFourierFeaturizingEstimator.ColumnOptions[toOutput.Length];`
	`1594`	`+ var infos = new RandomFourierExpansionEstimator.ColumnOptions[toOutput.Length];`
`1595`	`1595`	`for (int i = 0; i < toOutput.Length; ++i)`
`1596`	`1596`	`{`
`1597`	`1597`	`var tcol = (IColInput)toOutput[i];`
`1598`		`- infos[i] = new RandomFourierFeaturizingEstimator.ColumnOptions(outputNames[toOutput[i]], tcol.Config.Dimension, tcol.Config.UseCosAndSinBases, inputNames[tcol.Input], tcol.Config.Generator, tcol.Config.Seed);`
	`1598`	`+ infos[i] = new RandomFourierExpansionEstimator.ColumnOptions(outputNames[toOutput[i]], tcol.Config.Dimension, tcol.Config.UseCosAndSinBases, inputNames[tcol.Input], tcol.Config.Generator, tcol.Config.Seed);`
`1599`	`1599`	`}`
`1600`		`- return new RandomFourierFeaturizingEstimator(env, infos);`
	`1600`	`+ return new RandomFourierExpansionEstimator(env, infos);`
`1601`	`1601`	`}`
`1602`	`1602`	`}`
`1603`	`1603`
`@@ -1613,7 +1613,7 @@ public override IEstimator<ITransformer> Reconcile(IHostEnvironment env, Pipelin`
`1613`	`1613`	`/// <param name="generator">Which kernel to use. (if it is null, <see cref="GaussianKernel"/> is used.)</param>`
`1614`	`1614`	`/// <param name="seed">The seed of the random number generator for generating the new features. If not specified global random would be used.</param>`
`1615`	`1615`	`public static Vector<float> LowerVectorSizeWithRandomFourierTransformation(this Vector<float> input,`
`1616`		`- int dimension = RandomFourierFeaturizingEstimator.Defaults.Dimension, bool useCosAndSinBases = RandomFourierFeaturizingEstimator.Defaults.UseCosAndSinBases,`
	`1616`	`+ int dimension = RandomFourierExpansionEstimator.Defaults.Dimension, bool useCosAndSinBases = RandomFourierExpansionEstimator.Defaults.UseCosAndSinBases,`
`1617`	`1617`	`KernelBase generator = null, int? seed = null)`
`1618`	`1618`	`{`
`1619`	`1619`	`Contracts.CheckValue(input, nameof(input));`