Fixed all typos in word Transform. (#463)

joshua-light · TomFinley · commit 12e629882694 · 2018-07-03T07:55:23.000-07:00
* Fixed all typos in word `Transform`.
diff --git a/src/Microsoft.ML.PipelineInference/RecipeInference.cs b/src/Microsoft.ML.PipelineInference/RecipeInference.cs
@@ -157,15 +157,15 @@ public abstract class Recipe
             public virtual List<Type> AllowedPredictorTypes() => MacroUtils.PredictorTypes.ToList();
 
             protected virtual TransformInference.SuggestedTransform[] GetSuggestedTransforms(
-                TransformInference.InferenceResult tranformInferenceResult, Type predictorType)
+                TransformInference.InferenceResult transformInferenceResult, Type predictorType)
             {
                 List<Type> allowedTransforms = AllowedTransforms();
                 List<Type> qualifierTransforms = QualifierTransforms();
 
                 if (AllowedPredictorTypes().Any(type => type == predictorType) &&
-                    tranformInferenceResult.SuggestedTransforms.Any(transform => qualifierTransforms.Contains(transform.ExpertType)))
+                    transformInferenceResult.SuggestedTransforms.Any(transform => qualifierTransforms.Contains(transform.ExpertType)))
                 {
-                    return tranformInferenceResult.SuggestedTransforms
+                    return transformInferenceResult.SuggestedTransforms
                         .Where(transform => allowedTransforms.Contains(transform.ExpertType) || qualifierTransforms.Contains(transform.ExpertType))
                         .ToArray();
                 }
@@ -174,10 +174,10 @@ protected virtual TransformInference.SuggestedTransform[] GetSuggestedTransforms
             }
 
             public virtual IEnumerable<SuggestedRecipe> Apply(
-                TransformInference.InferenceResult tranformInferenceResult, Type predictorType, IChannel ch)
+                TransformInference.InferenceResult transformInferenceResult, Type predictorType, IChannel ch)
             {
                 TransformInference.SuggestedTransform[] transforms = GetSuggestedTransforms(
-                    tranformInferenceResult, predictorType);
+                    transformInferenceResult, predictorType);
 
                 if (transforms?.Length > 0)
                 {
@@ -431,7 +431,7 @@ public static SuggestedRecipe[] InferRecipesFromData(IHostEnvironment env, strin
             }
         }
 
-        public static InferenceResult InferRecipes(IHostEnvironment env, TransformInference.InferenceResult tranformInferenceResult,
+        public static InferenceResult InferRecipes(IHostEnvironment env, TransformInference.InferenceResult transformInferenceResult,
             Type predictorType)
         {
             Contracts.CheckValue(env, nameof(env));
@@ -441,7 +441,7 @@ public static InferenceResult InferRecipes(IHostEnvironment env, TransformInfere
             {
                 var list = new List<SuggestedRecipe>();
                 foreach (var recipe in GetRecipes())
-                    list.AddRange(recipe.Apply(tranformInferenceResult, predictorType, ch));
+                    list.AddRange(recipe.Apply(transformInferenceResult, predictorType, ch));
 
                 if (list.Count == 0)
                     ch.Info("No recipes are needed for the data.");
diff --git a/src/Microsoft.ML.PipelineInference/TransformInference.cs b/src/Microsoft.ML.PipelineInference/TransformInference.cs
@@ -792,7 +792,7 @@ public static StringBuilder GetTextTransformBigramTriCharArgument(string columnN
                 }
 
                 public static SuggestedTransform ConcatColumnsIntoOne(List<string> columnNames, string concatColumnName,
-                    Type tranformType, bool isNumeric)
+                    Type transformType, bool isNumeric)
                 {
                     StringBuilder columnArgument = new StringBuilder();
                     StringBuilder columnNameQuoted = new StringBuilder();
@@ -843,10 +843,10 @@ public static SuggestedTransform ConcatColumnsIntoOne(List<string> columnNames,
                         new SuggestedTransform(
                             $"Concatenate {columnsToConcat} columns into column {concatColumnName}",
                             new SubComponent<IDataTransform, SignatureDataTransform>("Concat",
-                                new[] { arguments }), tranformType, new TransformPipelineNode(epInput), -1, routingStructure);
+                                new[] { arguments }), transformType, new TransformPipelineNode(epInput), -1, routingStructure);
                 }
 
-                public static SuggestedTransform TextTransformUnigramTriChar(string srcColumn, string dstColumn, string arg, Type tranformType)
+                public static SuggestedTransform TextTransformUnigramTriChar(string srcColumn, string dstColumn, string arg, Type transformType)
                 {
                     StringBuilder columnArgument = InferenceHelpers.GetTextTransformUnigramTriCharArgument(srcColumn, dstColumn);
 
@@ -862,10 +862,10 @@ public static SuggestedTransform TextTransformUnigramTriChar(string srcColumn, s
                     };
 
                     return TextTransform(srcColumn, dstColumn, columnArgument.ToString(), "Unigram plus Trichar",
-                        tranformType, new TransformPipelineNode(nodeInput));
+                        transformType, new TransformPipelineNode(nodeInput));
                 }
 
-                public static SuggestedTransform TextTransformBigramTriChar(string srcColumn, string dstColumn, string arg, Type tranformType)
+                public static SuggestedTransform TextTransformBigramTriChar(string srcColumn, string dstColumn, string arg, Type transformType)
                 {
                     StringBuilder columnArgument = InferenceHelpers.GetTextTransformBigramTriCharArgument(srcColumn, dstColumn);
 
@@ -880,11 +880,11 @@ public static SuggestedTransform TextTransformBigramTriChar(string srcColumn, st
                     };
 
                     return TextTransform(srcColumn, dstColumn, columnArgument.ToString(), "Bigram plus Trichar",
-                        tranformType, new TransformPipelineNode(nodeInput));
+                        transformType, new TransformPipelineNode(nodeInput));
                 }
 
                 public static SuggestedTransform TextTransform(string srcColumn, string dstColumn, string arg,
-                    string outputMsg, Type tranformType, TransformPipelineNode pipelineNode)
+                    string outputMsg, Type transformType, TransformPipelineNode pipelineNode)
                 {
                     ColumnRoutingStructure.AnnotatedName[] columnsSource =
                         { new ColumnRoutingStructure.AnnotatedName { IsNumeric = false, Name = srcColumn } };
@@ -898,7 +898,7 @@ public static SuggestedTransform TextTransform(string srcColumn, string dstColum
                                 ") for column '{0}' and output to column '{1}'",
                                 srcColumn, dstColumn),
                             new SubComponent<IDataTransform, SignatureDataTransform>("Text", arg),
-                            tranformType, pipelineNode, -1, routingStructure);
+                            transformType, pipelineNode, -1, routingStructure);
                 }
             }
 
diff --git a/src/Microsoft.ML.Transforms/CategoricalTransform.cs b/src/Microsoft.ML.Transforms/CategoricalTransform.cs
@@ -186,7 +186,7 @@ public static IDataTransform CreateTransformCore(
             Contracts.CheckValue(columnOutputKinds, nameof(columnOutputKinds));
             Contracts.CheckParam(columns.Length == columnOutputKinds.Count, nameof(columns));
 
-            using (var ch = h.Start("Create Tranform Core"))
+            using (var ch = h.Start("Create Transform Core"))
             {
                 // Create the KeyToVectorTransform, if needed.
                 List<KeyToVectorTransform.Column> cols = new List<KeyToVectorTransform.Column>();
diff --git a/src/Microsoft.ML/ILearningPipelineItem.cs b/src/Microsoft.ML/ILearningPipelineItem.cs
@@ -32,7 +32,7 @@ public interface ILearningPipelineLoader : ILearningPipelineItem
 
     /// <summary>
     /// An item that can be added to the Learning Pipeline that can be trained and or return a IDataView.
-    /// This encapsulates an IDataView(input) and ITranformModel(output) object for a transform and
+    /// This encapsulates an IDataView(input) and ITransformModel(output) object for a transform and
     /// for a learner it will encapsulate IDataView(input) and IPredictorModel(output).
     /// </summary>
     public interface ILearningPipelineStep

Original file line number	Diff line number	Diff line change
`@@ -157,15 +157,15 @@ public abstract class Recipe`
`157`	`157`	`public virtual List<Type> AllowedPredictorTypes() => MacroUtils.PredictorTypes.ToList();`
`158`	`158`
`159`	`159`	`protected virtual TransformInference.SuggestedTransform[] GetSuggestedTransforms(`
`160`		`- TransformInference.InferenceResult tranformInferenceResult, Type predictorType)`
	`160`	`+ TransformInference.InferenceResult transformInferenceResult, Type predictorType)`
`161`	`161`	`{`
`162`	`162`	`List<Type> allowedTransforms = AllowedTransforms();`
`163`	`163`	`List<Type> qualifierTransforms = QualifierTransforms();`
`164`	`164`
`165`	`165`	`if (AllowedPredictorTypes().Any(type => type == predictorType) &&`
`166`		`- tranformInferenceResult.SuggestedTransforms.Any(transform => qualifierTransforms.Contains(transform.ExpertType)))`
	`166`	`+ transformInferenceResult.SuggestedTransforms.Any(transform => qualifierTransforms.Contains(transform.ExpertType)))`
`167`	`167`	`{`
`168`		`- return tranformInferenceResult.SuggestedTransforms`
	`168`	`+ return transformInferenceResult.SuggestedTransforms`
`169`	`169`	`.Where(transform => allowedTransforms.Contains(transform.ExpertType) \|\| qualifierTransforms.Contains(transform.ExpertType))`
`170`	`170`	`.ToArray();`
`171`	`171`	`}`
`@@ -174,10 +174,10 @@ protected virtual TransformInference.SuggestedTransform[] GetSuggestedTransforms`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`public virtual IEnumerable<SuggestedRecipe> Apply(`
`177`		`- TransformInference.InferenceResult tranformInferenceResult, Type predictorType, IChannel ch)`
	`177`	`+ TransformInference.InferenceResult transformInferenceResult, Type predictorType, IChannel ch)`
`178`	`178`	`{`
`179`	`179`	`TransformInference.SuggestedTransform[] transforms = GetSuggestedTransforms(`
`180`		`- tranformInferenceResult, predictorType);`
	`180`	`+ transformInferenceResult, predictorType);`
`181`	`181`
`182`	`182`	`if (transforms?.Length > 0)`
`183`	`183`	`{`
`@@ -431,7 +431,7 @@ public static SuggestedRecipe[] InferRecipesFromData(IHostEnvironment env, strin`
`431`	`431`	`}`
`432`	`432`	`}`
`433`	`433`
`434`		`- public static InferenceResult InferRecipes(IHostEnvironment env, TransformInference.InferenceResult tranformInferenceResult,`
	`434`	`+ public static InferenceResult InferRecipes(IHostEnvironment env, TransformInference.InferenceResult transformInferenceResult,`
`435`	`435`	`Type predictorType)`
`436`	`436`	`{`
`437`	`437`	`Contracts.CheckValue(env, nameof(env));`
`@@ -441,7 +441,7 @@ public static InferenceResult InferRecipes(IHostEnvironment env, TransformInfere`
`441`	`441`	`{`
`442`	`442`	`var list = new List<SuggestedRecipe>();`
`443`	`443`	`foreach (var recipe in GetRecipes())`
`444`		`- list.AddRange(recipe.Apply(tranformInferenceResult, predictorType, ch));`
	`444`	`+ list.AddRange(recipe.Apply(transformInferenceResult, predictorType, ch));`
`445`	`445`
`446`	`446`	`if (list.Count == 0)`
`447`	`447`	`ch.Info("No recipes are needed for the data.");`
Original file line number	Diff line number	Diff line change
`@@ -792,7 +792,7 @@ public static StringBuilder GetTextTransformBigramTriCharArgument(string columnN`
`792`	`792`	`}`
`793`	`793`
`794`	`794`	`public static SuggestedTransform ConcatColumnsIntoOne(List<string> columnNames, string concatColumnName,`
`795`		`- Type tranformType, bool isNumeric)`
	`795`	`+ Type transformType, bool isNumeric)`
`796`	`796`	`{`
`797`	`797`	`StringBuilder columnArgument = new StringBuilder();`
`798`	`798`	`StringBuilder columnNameQuoted = new StringBuilder();`
`@@ -843,10 +843,10 @@ public static SuggestedTransform ConcatColumnsIntoOne(List<string> columnNames,`
`843`	`843`	`new SuggestedTransform(`
`844`	`844`	`$"Concatenate {columnsToConcat} columns into column {concatColumnName}",`
`845`	`845`	`new SubComponent<IDataTransform, SignatureDataTransform>("Concat",`
`846`		`- new[] { arguments }), tranformType, new TransformPipelineNode(epInput), -1, routingStructure);`
	`846`	`+ new[] { arguments }), transformType, new TransformPipelineNode(epInput), -1, routingStructure);`
`847`	`847`	`}`
`848`	`848`
`849`		`- public static SuggestedTransform TextTransformUnigramTriChar(string srcColumn, string dstColumn, string arg, Type tranformType)`
	`849`	`+ public static SuggestedTransform TextTransformUnigramTriChar(string srcColumn, string dstColumn, string arg, Type transformType)`
`850`	`850`	`{`
`851`	`851`	`StringBuilder columnArgument = InferenceHelpers.GetTextTransformUnigramTriCharArgument(srcColumn, dstColumn);`
`852`	`852`
`@@ -862,10 +862,10 @@ public static SuggestedTransform TextTransformUnigramTriChar(string srcColumn, s`
`862`	`862`	`};`
`863`	`863`
`864`	`864`	`return TextTransform(srcColumn, dstColumn, columnArgument.ToString(), "Unigram plus Trichar",`
`865`		`- tranformType, new TransformPipelineNode(nodeInput));`
	`865`	`+ transformType, new TransformPipelineNode(nodeInput));`
`866`	`866`	`}`
`867`	`867`
`868`		`- public static SuggestedTransform TextTransformBigramTriChar(string srcColumn, string dstColumn, string arg, Type tranformType)`
	`868`	`+ public static SuggestedTransform TextTransformBigramTriChar(string srcColumn, string dstColumn, string arg, Type transformType)`
`869`	`869`	`{`
`870`	`870`	`StringBuilder columnArgument = InferenceHelpers.GetTextTransformBigramTriCharArgument(srcColumn, dstColumn);`
`871`	`871`
`@@ -880,11 +880,11 @@ public static SuggestedTransform TextTransformBigramTriChar(string srcColumn, st`
`880`	`880`	`};`
`881`	`881`
`882`	`882`	`return TextTransform(srcColumn, dstColumn, columnArgument.ToString(), "Bigram plus Trichar",`
`883`		`- tranformType, new TransformPipelineNode(nodeInput));`
	`883`	`+ transformType, new TransformPipelineNode(nodeInput));`
`884`	`884`	`}`
`885`	`885`
`886`	`886`	`public static SuggestedTransform TextTransform(string srcColumn, string dstColumn, string arg,`
`887`		`- string outputMsg, Type tranformType, TransformPipelineNode pipelineNode)`
	`887`	`+ string outputMsg, Type transformType, TransformPipelineNode pipelineNode)`
`888`	`888`	`{`
`889`	`889`	`ColumnRoutingStructure.AnnotatedName[] columnsSource =`
`890`	`890`	`{ new ColumnRoutingStructure.AnnotatedName { IsNumeric = false, Name = srcColumn } };`
`@@ -898,7 +898,7 @@ public static SuggestedTransform TextTransform(string srcColumn, string dstColum`
`898`	`898`	`") for column '{0}' and output to column '{1}'",`
`899`	`899`	`srcColumn, dstColumn),`
`900`	`900`	`new SubComponent<IDataTransform, SignatureDataTransform>("Text", arg),`
`901`		`- tranformType, pipelineNode, -1, routingStructure);`
	`901`	`+ transformType, pipelineNode, -1, routingStructure);`
`902`	`902`	`}`
`903`	`903`	`}`
`904`	`904`
Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,7 @@ public static IDataTransform CreateTransformCore(`
`186`	`186`	`Contracts.CheckValue(columnOutputKinds, nameof(columnOutputKinds));`
`187`	`187`	`Contracts.CheckParam(columns.Length == columnOutputKinds.Count, nameof(columns));`
`188`	`188`
`189`		`- using (var ch = h.Start("Create Tranform Core"))`
	`189`	`+ using (var ch = h.Start("Create Transform Core"))`
`190`	`190`	`{`
`191`	`191`	`// Create the KeyToVectorTransform, if needed.`
`192`	`192`	`List<KeyToVectorTransform.Column> cols = new List<KeyToVectorTransform.Column>();`