Rename new class to CustomMappingFactory.

Author: eerhardt

docs/code/MlNetCookBook.md

@@ -977,17 +977,17 @@ Here is a complete example that saves and loads a model with a custom mapping.
 /// <summary>
 /// One class that contains the custom mapping functionality that we need for our model.
 /// 
-/// It has a [CustomMappingTransformerFactoryAttribute] on it and
-/// derives from CustomMappingTransformerFactory{TSrc, TDst}.
+/// It has a <see cref="CustomMappingFactoryAttributeAttribute"/> on it and
+/// derives from <see cref="CustomMappingFactory{TSrc, TDst}"/>.
 /// </summary>
-[CustomMappingTransformerFactory(nameof(CustomMappings.IncomeMapping))]
-public class CustomMappings : CustomMappingTransformerFactory<InputRow, OutputRow>
+[CustomMappingFactoryAttribute(nameof(CustomMappings.IncomeMapping))]
+public class CustomMappings : CustomMappingFactory<InputRow, OutputRow>
 {
     // This is the custom mapping. We now separate it into a method, so that we can use it both in training and in loading.
     public static void IncomeMapping(InputRow input, OutputRow output) => output.Label = input.Income > 50000;
 
     // This factory method will be called when loading the model to get the mapping operation.
-    public override Action<InputRow, OutputRow> GetTransformer()
+    public override Action<InputRow, OutputRow> GetMapping()
     {
         return IncomeMapping;
     }

src/Microsoft.ML.Transforms/CustomMappingTransformerFactory.cs renamed to src/Microsoft.ML.Transforms/CustomMappingFactory.cs

@@ -8,36 +8,39 @@
 namespace Microsoft.ML.Transforms
 {
     /// <summary>
-    /// Place this attribute onto a type to cause it to be considered a custom mapping transformer factory.
+    /// Place this attribute onto a type to cause it to be considered a custom mapping factory.
     /// </summary>
     [AttributeUsage(AttributeTargets.Class)]
-    public sealed class CustomMappingTransformerFactoryAttribute : ExtensionBaseAttribute
+    public sealed class CustomMappingFactoryAttributeAttribute : ExtensionBaseAttribute
     {
-        public CustomMappingTransformerFactoryAttribute(string contractName)
+        public CustomMappingFactoryAttributeAttribute(string contractName)
             : base(contractName)
         {
         }
     }
 
-    internal interface ICustomMappingTransformerFactory
+    internal interface ICustomMappingFactory
     {
-        ITransformer CreateTransformerObject(IHostEnvironment env, string contractName);
+        ITransformer CreateTransformer(IHostEnvironment env, string contractName);
     }
 
     /// <summary>
-    /// The base type for custom mapping transformer factories.
+    /// The base type for custom mapping factories.
     /// </summary>
     /// <typeparam name="TSrc">The type that describes what 'source' columns are consumed from the input <see cref="IDataView"/>.</typeparam>
     /// <typeparam name="TDst">The type that describes what new columns are added by this transform.</typeparam>
-    public abstract class CustomMappingTransformerFactory<TSrc, TDst> : ICustomMappingTransformerFactory
+    public abstract class CustomMappingFactory<TSrc, TDst> : ICustomMappingFactory
         where TSrc : class, new()
         where TDst : class, new()
     {
-        public abstract Action<TSrc, TDst> GetTransformer();
+        /// <summary>
+        /// Returns the mapping delegate that maps from <typeparamref name="TSrc"/> inputs to <typeparamref name="TDst"/> outputs.
+        /// </summary>
+        public abstract Action<TSrc, TDst> GetMapping();
 
-        ITransformer ICustomMappingTransformerFactory.CreateTransformerObject(IHostEnvironment env, string contractName)
+        ITransformer ICustomMappingFactory.CreateTransformer(IHostEnvironment env, string contractName)
         {
-            Action<TSrc, TDst> mapAction = GetTransformer();
+            Action<TSrc, TDst> mapAction = GetMapping();
             return new CustomMappingTransformer<TSrc, TDst>(env, mapAction, contractName);
         }
     }

src/Microsoft.ML.Transforms/LambdaTransform.cs

@@ -68,13 +68,13 @@ private static ITransformer Create(IHostEnvironment env, ModelLoadContext ctx)
 
             var contractName = ctx.LoadString();
 
-            object factoryObject = env.ComponentCatalog.GetExtensionValue(env, typeof(CustomMappingTransformerFactoryAttribute), contractName);
-            if (!(factoryObject is ICustomMappingTransformerFactory transformerFactory))
+            object factoryObject = env.ComponentCatalog.GetExtensionValue(env, typeof(CustomMappingFactoryAttributeAttribute), contractName);
+            if (!(factoryObject is ICustomMappingFactory mappingFactory))
             {
-                throw env.Except($"The class with contract '{contractName}' must derive from '{typeof(CustomMappingTransformerFactory<,>).FullName}'.");
+                throw env.Except($"The class with contract '{contractName}' must derive from '{typeof(CustomMappingFactory<,>).FullName}'.");
             }
 
-            return transformerFactory.CreateTransformerObject(env, contractName);
+            return mappingFactory.CreateTransformer(env, contractName);
         }
 
         /// <summary>

test/Microsoft.ML.Tests/Scenarios/Api/CookbookSamples/CookbookSamplesDynamicApi.cs

@@ -492,17 +492,17 @@ public void CustomTransformer()
         /// <summary>
         /// One class that contains the custom mapping functionality that we need for our model.
         /// 
-        /// It has a <see cref="CustomMappingTransformerFactoryAttribute"/> on it and
-        /// derives from <see cref="CustomMappingTransformerFactory{TSrc, TDst}"/>.
+        /// It has a <see cref="CustomMappingFactoryAttributeAttribute"/> on it and
+        /// derives from <see cref="CustomMappingFactory{TSrc, TDst}"/>.
         /// </summary>
-        [CustomMappingTransformerFactory(nameof(CustomMappings.IncomeMapping))]
-        public class CustomMappings : CustomMappingTransformerFactory<InputRow, OutputRow>
+        [CustomMappingFactoryAttribute(nameof(CustomMappings.IncomeMapping))]
+        public class CustomMappings : CustomMappingFactory<InputRow, OutputRow>
         {
             // This is the custom mapping. We now separate it into a method, so that we can use it both in training and in loading.
             public static void IncomeMapping(InputRow input, OutputRow output) => output.Label = input.Income > 50000;
 
             // This factory method will be called when loading the model to get the mapping operation.
-            public override Action<InputRow, OutputRow> GetTransformer()
+            public override Action<InputRow, OutputRow> GetMapping()
             {
                 return IncomeMapping;
             }

test/Microsoft.ML.Tests/Transformers/CustomMappingTests.cs

@@ -30,15 +30,15 @@ public class MyOutput
             public string Together { get; set; }
         }
 
-        [CustomMappingTransformerFactory("MyLambda")]
-        public class MyLambda : CustomMappingTransformerFactory<MyInput, MyOutput>
+        [CustomMappingFactoryAttribute("MyLambda")]
+        public class MyLambda : CustomMappingFactory<MyInput, MyOutput>
         {
             public static void MyAction(MyInput input, MyOutput output)
             {
                 output.Together = $"{input.Float1} + {string.Join(", ", input.Float4)}";
             }
 
-            public override Action<MyInput, MyOutput> GetTransformer()
+            public override Action<MyInput, MyOutput> GetMapping()
             {
                 return MyAction;
             }