Get rid of value tuples n the public API (#2950)

Ivanidzo4ka · TomFinley · commit 4c29a09b0be3 · 2019-03-14T10:54:04.000-07:00
diff --git a/src/Microsoft.ML.StaticPipe/LdaStaticExtensions.cs b/src/Microsoft.ML.StaticPipe/LdaStaticExtensions.cs
@@ -20,8 +20,8 @@ public sealed class LatentDirichletAllocationFitResult
         /// <param name="result"></param>
         public delegate void OnFit(LatentDirichletAllocationFitResult result);
 
-        public LatentDirichletAllocationTransformer.LdaSummary LdaTopicSummary;
-        public LatentDirichletAllocationFitResult(LatentDirichletAllocationTransformer.LdaSummary ldaTopicSummary)
+        public LatentDirichletAllocationTransformer.ModelParameters LdaTopicSummary;
+        public LatentDirichletAllocationFitResult(LatentDirichletAllocationTransformer.ModelParameters ldaTopicSummary)
         {
             LdaTopicSummary = ldaTopicSummary;
         }
@@ -43,11 +43,11 @@ private struct Config
             public readonly int NumberOfBurninIterations;
             public readonly bool ResetRandomGenerator;
 
-            public readonly Action<LatentDirichletAllocationTransformer.LdaSummary> OnFit;
+            public readonly Action<LatentDirichletAllocationTransformer.ModelParameters> OnFit;
 
             public Config(int numberOfTopics, Single alphaSum, Single beta, int samplingStepCount, int maximumNumberOfIterations, int likelihoodInterval,
                 int numberOfThreads, int maximumTokenCountPerDocument, int numberOfSummaryTermsPerTopic, int numberOfBurninIterations, bool resetRandomGenerator,
-                Action<LatentDirichletAllocationTransformer.LdaSummary> onFit)
+                Action<LatentDirichletAllocationTransformer.ModelParameters> onFit)
             {
                 NumberOfTopics = numberOfTopics;
                 AlphaSum = alphaSum;
@@ -65,7 +65,7 @@ public Config(int numberOfTopics, Single alphaSum, Single beta, int samplingStep
             }
         }
 
-        private static Action<LatentDirichletAllocationTransformer.LdaSummary> Wrap(LatentDirichletAllocationFitResult.OnFit onFit)
+        private static Action<LatentDirichletAllocationTransformer.ModelParameters> Wrap(LatentDirichletAllocationFitResult.OnFit onFit)
         {
             if (onFit == null)
                 return null;
diff --git a/src/Microsoft.ML.Transforms/MissingValueDroppingTransformer.cs b/src/Microsoft.ML.Transforms/MissingValueDroppingTransformer.cs
@@ -30,7 +30,7 @@
 namespace Microsoft.ML.Transforms
 {
     /// <include file='doc.xml' path='doc/members/member[@name="NADrop"]'/>
-    public sealed class MissingValueDroppingTransformer : OneToOneTransformerBase
+    internal sealed class MissingValueDroppingTransformer : OneToOneTransformerBase
     {
         internal sealed class Options : TransformInputBase
         {
@@ -76,7 +76,7 @@ private static VersionInfo GetVersionInfo()
         /// <summary>
         /// The names of the input columns of the transformation and the corresponding names for the output columns.
         /// </summary>
-        public IReadOnlyList<(string outputColumnName, string inputColumnName)> Columns => ColumnPairs.AsReadOnly();
+        internal IReadOnlyList<(string outputColumnName, string inputColumnName)> Columns => ColumnPairs.AsReadOnly();
 
         /// <summary>
         /// Initializes a new instance of <see cref="MissingValueDroppingTransformer"/>
@@ -339,55 +339,4 @@ private void DropNAs<TDst>(ref VBuffer<TDst> src, ref VBuffer<TDst> dst, InPredi
             }
         }
     }
-    /// <summary>
-    /// Drops missing values from columns.
-    /// </summary>
-    public sealed class MissingValueDroppingEstimator : TrivialEstimator<MissingValueDroppingTransformer>
-    {
-        /// <summary>
-        /// Drops missing values from columns.
-        /// </summary>
-        /// <param name="env">The environment to use.</param>
-        /// <param name="columns">The names of the input columns of the transformation and the corresponding names for the output columns.</param>
-        internal MissingValueDroppingEstimator(IHostEnvironment env, params (string outputColumnName, string inputColumnName)[] columns)
-            : base(Contracts.CheckRef(env, nameof(env)).Register(nameof(MissingValueDroppingEstimator)), new MissingValueDroppingTransformer(env, columns))
-        {
-            Contracts.CheckValue(env, nameof(env));
-        }
-
-        /// <summary>
-        /// Drops missing values from columns.
-        /// </summary>
-        /// <param name="env">The environment to use.</param>
-        /// <param name="outputColumnName">Name of the column resulting from the transformation of <paramref name="inputColumnName"/>.</param>
-        /// <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>
-        internal MissingValueDroppingEstimator(IHostEnvironment env, string outputColumnName, string inputColumnName = null)
-            : this(env, (outputColumnName, inputColumnName ?? outputColumnName))
-        {
-        }
-
-        /// <summary>
-        /// Returns the <see cref="SchemaShape"/> of the schema which will be produced by the transformer.
-        /// Used for schema propagation and verification in a pipeline.
-        /// </summary>
-        public override SchemaShape GetOutputSchema(SchemaShape inputSchema)
-        {
-            Host.CheckValue(inputSchema, nameof(inputSchema));
-            var result = inputSchema.ToDictionary(x => x.Name);
-            foreach (var colPair in Transformer.Columns)
-            {
-                if (!inputSchema.TryFindColumn(colPair.inputColumnName, out var col) || !Data.Conversion.Conversions.Instance.TryGetIsNAPredicate(col.ItemType, out Delegate del))
-                    throw Host.ExceptSchemaMismatch(nameof(inputSchema), "input", colPair.inputColumnName);
-                if (!(col.Kind == SchemaShape.Column.VectorKind.Vector || col.Kind == SchemaShape.Column.VectorKind.VariableVector))
-                    throw Host.ExceptSchemaMismatch(nameof(inputSchema), "input", colPair.inputColumnName, "known-size vector", col.GetTypeString());
-                var metadata = new List<SchemaShape.Column>();
-                if (col.Annotations.TryFindColumn(AnnotationUtils.Kinds.KeyValues, out var keyMeta))
-                    metadata.Add(keyMeta);
-                if (col.Annotations.TryFindColumn(AnnotationUtils.Kinds.IsNormalized, out var normMeta))
-                    metadata.Add(normMeta);
-                result[colPair.outputColumnName] = new SchemaShape.Column(colPair.outputColumnName, SchemaShape.Column.VectorKind.VariableVector, col.ItemType, false, new SchemaShape(metadata.ToArray()));
-            }
-            return new SchemaShape(result.Values);
-        }
-    }
 }
diff --git a/src/Microsoft.ML.Transforms/Text/LdaTransform.cs b/src/Microsoft.ML.Transforms/Text/LdaTransform.cs
@@ -163,27 +163,50 @@ internal bool TryUnparse(StringBuilder sb)
         /// <summary>
         /// Provide details about the topics discovered by <a href="https://arxiv.org/abs/1412.1576">LightLDA.</a>
         /// </summary>
-        public sealed class LdaSummary
+        public sealed class ModelParameters
         {
+            public struct ItemScore
+            {
+                public readonly int Item;
+                public readonly float Score;
+                public ItemScore(int item, float score)
+                {
+                    Item = item;
+                    Score = score;
+                }
+            }
+            public struct WordItemScore
+            {
+                public readonly int Item;
+                public readonly string Word;
+                public readonly float Score;
+                public WordItemScore(int item, string word, float score)
+                {
+                    Item = item;
+                    Word = word;
+                    Score = score;
+                }
+            }
+
             // For each topic, provide information about the (item, score) pairs.
-            public readonly ImmutableArray<List<(int Item, float Score)>> ItemScoresPerTopic;
+            public readonly IReadOnlyList<IReadOnlyList<ItemScore>> ItemScoresPerTopic;
 
             // For each topic, provide information about the (item, word, score) tuple.
-            public readonly ImmutableArray<List<(int Item, string Word, float Score)>> WordScoresPerTopic;
+            public readonly IReadOnlyList<IReadOnlyList<WordItemScore>> WordScoresPerTopic;
 
-            internal LdaSummary(ImmutableArray<List<(int Item, float Score)>> itemScoresPerTopic)
+            internal ModelParameters(IReadOnlyList<IReadOnlyList<ItemScore>> itemScoresPerTopic)
             {
                 ItemScoresPerTopic = itemScoresPerTopic;
             }
 
-            internal LdaSummary(ImmutableArray<List<(int Item, string Word, float Score)>> wordScoresPerTopic)
+            internal ModelParameters(IReadOnlyList<IReadOnlyList<WordItemScore>> wordScoresPerTopic)
             {
                 WordScoresPerTopic = wordScoresPerTopic;
             }
         }
 
         [BestFriend]
-        internal LdaSummary GetLdaDetails(int iinfo)
+        internal ModelParameters GetLdaDetails(int iinfo)
         {
             Contracts.Assert(0 <= iinfo && iinfo < _ldas.Length);
 
@@ -302,40 +325,40 @@ internal LdaState(IExceptionContext ectx, ModelLoadContext ctx)
                 }
             }
 
-            internal LdaSummary GetLdaSummary(VBuffer<ReadOnlyMemory<char>> mapping)
+            internal ModelParameters GetLdaSummary(VBuffer<ReadOnlyMemory<char>> mapping)
             {
                 if (mapping.Length == 0)
                 {
-                    var itemScoresPerTopicBuilder = ImmutableArray.CreateBuilder<List<(int Item, float Score)>>();
+                    var itemScoresPerTopicBuilder = ImmutableArray.CreateBuilder<List<ModelParameters.ItemScore>>();
                     for (int i = 0; i < _ldaTrainer.NumTopic; i++)
                     {
                         var scores = _ldaTrainer.GetTopicSummary(i);
-                        var itemScores = new List<(int, float)>();
+                        var itemScores = new List<ModelParameters.ItemScore>();
                         foreach (KeyValuePair<int, float> p in scores)
                         {
-                            itemScores.Add((p.Key, p.Value));
+                            itemScores.Add(new ModelParameters.ItemScore(p.Key, p.Value));
                         }
 
                         itemScoresPerTopicBuilder.Add(itemScores);
                     }
-                    return new LdaSummary(itemScoresPerTopicBuilder.ToImmutable());
+                    return new ModelParameters(itemScoresPerTopicBuilder.ToImmutable());
                 }
                 else
                 {
                     ReadOnlyMemory<char> slotName = default;
-                    var wordScoresPerTopicBuilder = ImmutableArray.CreateBuilder<List<(int Item, string Word, float Score)>>();
+                    var wordScoresPerTopicBuilder = ImmutableArray.CreateBuilder<List<ModelParameters.WordItemScore>>();
                     for (int i = 0; i < _ldaTrainer.NumTopic; i++)
                     {
                         var scores = _ldaTrainer.GetTopicSummary(i);
-                        var wordScores = new List<(int, string, float)>();
+                        var wordScores = new List<ModelParameters.WordItemScore>();
                         foreach (KeyValuePair<int, float> p in scores)
                         {
                             mapping.GetItemOrDefault(p.Key, ref slotName);
-                            wordScores.Add((p.Key, slotName.ToString(), p.Value));
+                            wordScores.Add(new ModelParameters.WordItemScore(p.Key, slotName.ToString(), p.Value));
                         }
                         wordScoresPerTopicBuilder.Add(wordScores);
                     }
-                    return new LdaSummary(wordScoresPerTopicBuilder.ToImmutable());
+                    return new ModelParameters(wordScoresPerTopicBuilder.ToImmutable());
                 }
             }
 
diff --git a/src/Microsoft.ML.Transforms/Text/WordEmbeddingsExtractor.cs b/src/Microsoft.ML.Transforms/Text/WordEmbeddingsExtractor.cs
@@ -93,11 +93,6 @@ internal static VersionInfo GetVersionInfo()
         private readonly Model _currentVocab;
         private static Dictionary<string, WeakReference<Model>> _vocab = new Dictionary<string, WeakReference<Model>>();
 
-        /// <summary>
-        /// The names of the output and input column pairs on which the transformation is applied.
-        /// </summary>
-        private IReadOnlyCollection<(string outputColumnName, string inputColumnName)> Columns => ColumnPairs.AsReadOnly();
-
         private sealed class Model
         {
             public readonly BigArray<float> WordVectors;
@@ -335,7 +330,7 @@ protected override DataViewSchema.DetachedColumn[] GetOutputColumnsCore()
 
             public void SaveAsOnnx(OnnxContext ctx)
             {
-                foreach (var (outputColumnName, inputColumnName) in _parent.Columns)
+                foreach (var (outputColumnName, inputColumnName) in _parent.ColumnPairs)
                 {
                     var srcVariableName = ctx.GetVariableName(inputColumnName);
                     var schema = _parent.GetOutputSchema(InputSchema);
diff --git a/test/Microsoft.ML.Benchmarks/Helpers/EnvironmentFactory.cs b/test/Microsoft.ML.Benchmarks/Helpers/EnvironmentFactory.cs
@@ -41,7 +41,7 @@ internal static MLContext CreateRankingEnvironment<TEvaluator, TLoader, TTransfo
             environment.ComponentCatalog.RegisterAssembly(typeof(TTransformer).Assembly);
             environment.ComponentCatalog.RegisterAssembly(typeof(TTrainer).Assembly);
 
-            environment.ComponentCatalog.RegisterAssembly(typeof(MissingValueDroppingTransformer).Assembly);
+            environment.ComponentCatalog.RegisterAssembly(typeof(OneHotEncodingTransformer).Assembly);
 
             return ctx;
         }
diff --git a/test/Microsoft.ML.StaticPipelineTesting/StaticPipeTests.cs b/test/Microsoft.ML.StaticPipelineTesting/StaticPipeTests.cs
@@ -670,7 +670,7 @@ public void LdaTopicModel()
             var data = reader.Load(dataSource);
 
             // This will be populated once we call fit.
-            LdaSummary ldaSummary;
+            ModelParameters ldaSummary;
 
             var est = data.MakeNewEstimator()
                 .Append(r => (

Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,8 @@ public sealed class LatentDirichletAllocationFitResult`
`20`	`20`	`/// <param name="result"></param>`
`21`	`21`	`public delegate void OnFit(LatentDirichletAllocationFitResult result);`
`22`	`22`
`23`		`- public LatentDirichletAllocationTransformer.LdaSummary LdaTopicSummary;`
`24`		`- public LatentDirichletAllocationFitResult(LatentDirichletAllocationTransformer.LdaSummary ldaTopicSummary)`
	`23`	`+ public LatentDirichletAllocationTransformer.ModelParameters LdaTopicSummary;`
	`24`	`+ public LatentDirichletAllocationFitResult(LatentDirichletAllocationTransformer.ModelParameters ldaTopicSummary)`
`25`	`25`	`{`
`26`	`26`	`LdaTopicSummary = ldaTopicSummary;`
`27`	`27`	`}`
`@@ -43,11 +43,11 @@ private struct Config`
`43`	`43`	`public readonly int NumberOfBurninIterations;`
`44`	`44`	`public readonly bool ResetRandomGenerator;`
`45`	`45`
`46`		`- public readonly Action<LatentDirichletAllocationTransformer.LdaSummary> OnFit;`
	`46`	`+ public readonly Action<LatentDirichletAllocationTransformer.ModelParameters> OnFit;`
`47`	`47`
`48`	`48`	`public Config(int numberOfTopics, Single alphaSum, Single beta, int samplingStepCount, int maximumNumberOfIterations, int likelihoodInterval,`
`49`	`49`	`int numberOfThreads, int maximumTokenCountPerDocument, int numberOfSummaryTermsPerTopic, int numberOfBurninIterations, bool resetRandomGenerator,`
`50`		`- Action<LatentDirichletAllocationTransformer.LdaSummary> onFit)`
	`50`	`+ Action<LatentDirichletAllocationTransformer.ModelParameters> onFit)`
`51`	`51`	`{`
`52`	`52`	`NumberOfTopics = numberOfTopics;`
`53`	`53`	`AlphaSum = alphaSum;`
`@@ -65,7 +65,7 @@ public Config(int numberOfTopics, Single alphaSum, Single beta, int samplingStep`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
`68`		`- private static Action<LatentDirichletAllocationTransformer.LdaSummary> Wrap(LatentDirichletAllocationFitResult.OnFit onFit)`
	`68`	`+ private static Action<LatentDirichletAllocationTransformer.ModelParameters> Wrap(LatentDirichletAllocationFitResult.OnFit onFit)`
`69`	`69`	`{`
`70`	`70`	`if (onFit == null)`
`71`	`71`	`return null;`
Original file line number	Diff line number	Diff line change
`@@ -163,27 +163,50 @@ internal bool TryUnparse(StringBuilder sb)`
`163`	`163`	`/// <summary>`
`164`	`164`	`/// Provide details about the topics discovered by <a href="https://arxiv.org/abs/1412.1576">LightLDA.</a>`
`165`	`165`	`/// </summary>`
`166`		`- public sealed class LdaSummary`
	`166`	`+ public sealed class ModelParameters`
`167`	`167`	`{`
	`168`	`+ public struct ItemScore`
	`169`	`+ {`
	`170`	`+ public readonly int Item;`
	`171`	`+ public readonly float Score;`
	`172`	`+ public ItemScore(int item, float score)`
	`173`	`+ {`
	`174`	`+ Item = item;`
	`175`	`+ Score = score;`
	`176`	`+ }`
	`177`	`+ }`
	`178`	`+ public struct WordItemScore`
	`179`	`+ {`
	`180`	`+ public readonly int Item;`
	`181`	`+ public readonly string Word;`
	`182`	`+ public readonly float Score;`
	`183`	`+ public WordItemScore(int item, string word, float score)`
	`184`	`+ {`
	`185`	`+ Item = item;`
	`186`	`+ Word = word;`
	`187`	`+ Score = score;`
	`188`	`+ }`
	`189`	`+ }`
	`190`	`+`
`168`	`191`	`// For each topic, provide information about the (item, score) pairs.`
`169`		`- public readonly ImmutableArray<List<(int Item, float Score)>> ItemScoresPerTopic;`
	`192`	`+ public readonly IReadOnlyList<IReadOnlyList<ItemScore>> ItemScoresPerTopic;`
`170`	`193`
`171`	`194`	`// For each topic, provide information about the (item, word, score) tuple.`
`172`		`- public readonly ImmutableArray<List<(int Item, string Word, float Score)>> WordScoresPerTopic;`
	`195`	`+ public readonly IReadOnlyList<IReadOnlyList<WordItemScore>> WordScoresPerTopic;`
`173`	`196`
`174`		`- internal LdaSummary(ImmutableArray<List<(int Item, float Score)>> itemScoresPerTopic)`
	`197`	`+ internal ModelParameters(IReadOnlyList<IReadOnlyList<ItemScore>> itemScoresPerTopic)`
`175`	`198`	`{`
`176`	`199`	`ItemScoresPerTopic = itemScoresPerTopic;`
`177`	`200`	`}`
`178`	`201`
`179`		`- internal LdaSummary(ImmutableArray<List<(int Item, string Word, float Score)>> wordScoresPerTopic)`
	`202`	`+ internal ModelParameters(IReadOnlyList<IReadOnlyList<WordItemScore>> wordScoresPerTopic)`
`180`	`203`	`{`
`181`	`204`	`WordScoresPerTopic = wordScoresPerTopic;`
`182`	`205`	`}`
`183`	`206`	`}`
`184`	`207`
`185`	`208`	`[BestFriend]`
`186`		`- internal LdaSummary GetLdaDetails(int iinfo)`
	`209`	`+ internal ModelParameters GetLdaDetails(int iinfo)`
`187`	`210`	`{`
`188`	`211`	`Contracts.Assert(0 <= iinfo && iinfo < _ldas.Length);`
`189`	`212`
`@@ -302,40 +325,40 @@ internal LdaState(IExceptionContext ectx, ModelLoadContext ctx)`
`302`	`325`	`}`
`303`	`326`	`}`
`304`	`327`
`305`		`- internal LdaSummary GetLdaSummary(VBuffer<ReadOnlyMemory<char>> mapping)`
	`328`	`+ internal ModelParameters GetLdaSummary(VBuffer<ReadOnlyMemory<char>> mapping)`
`306`	`329`	`{`
`307`	`330`	`if (mapping.Length == 0)`
`308`	`331`	`{`
`309`		`- var itemScoresPerTopicBuilder = ImmutableArray.CreateBuilder<List<(int Item, float Score)>>();`
	`332`	`+ var itemScoresPerTopicBuilder = ImmutableArray.CreateBuilder<List<ModelParameters.ItemScore>>();`
`310`	`333`	`for (int i = 0; i < _ldaTrainer.NumTopic; i++)`
`311`	`334`	`{`
`312`	`335`	`var scores = _ldaTrainer.GetTopicSummary(i);`
`313`		`- var itemScores = new List<(int, float)>();`
	`336`	`+ var itemScores = new List<ModelParameters.ItemScore>();`
`314`	`337`	`foreach (KeyValuePair<int, float> p in scores)`
`315`	`338`	`{`
`316`		`- itemScores.Add((p.Key, p.Value));`
	`339`	`+ itemScores.Add(new ModelParameters.ItemScore(p.Key, p.Value));`
`317`	`340`	`}`
`318`	`341`
`319`	`342`	`itemScoresPerTopicBuilder.Add(itemScores);`
`320`	`343`	`}`
`321`		`- return new LdaSummary(itemScoresPerTopicBuilder.ToImmutable());`
	`344`	`+ return new ModelParameters(itemScoresPerTopicBuilder.ToImmutable());`
`322`	`345`	`}`
`323`	`346`	`else`
`324`	`347`	`{`
`325`	`348`	`ReadOnlyMemory<char> slotName = default;`
`326`		`- var wordScoresPerTopicBuilder = ImmutableArray.CreateBuilder<List<(int Item, string Word, float Score)>>();`
	`349`	`+ var wordScoresPerTopicBuilder = ImmutableArray.CreateBuilder<List<ModelParameters.WordItemScore>>();`
`327`	`350`	`for (int i = 0; i < _ldaTrainer.NumTopic; i++)`
`328`	`351`	`{`
`329`	`352`	`var scores = _ldaTrainer.GetTopicSummary(i);`
`330`		`- var wordScores = new List<(int, string, float)>();`
	`353`	`+ var wordScores = new List<ModelParameters.WordItemScore>();`
`331`	`354`	`foreach (KeyValuePair<int, float> p in scores)`
`332`	`355`	`{`
`333`	`356`	`mapping.GetItemOrDefault(p.Key, ref slotName);`
`334`		`- wordScores.Add((p.Key, slotName.ToString(), p.Value));`
	`357`	`+ wordScores.Add(new ModelParameters.WordItemScore(p.Key, slotName.ToString(), p.Value));`
`335`	`358`	`}`
`336`	`359`	`wordScoresPerTopicBuilder.Add(wordScores);`
`337`	`360`	`}`
`338`		`- return new LdaSummary(wordScoresPerTopicBuilder.ToImmutable());`
	`361`	`+ return new ModelParameters(wordScoresPerTopicBuilder.ToImmutable());`
`339`	`362`	`}`
`340`	`363`	`}`
`341`	`364`
Original file line number	Diff line number	Diff line change
`@@ -93,11 +93,6 @@ internal static VersionInfo GetVersionInfo()`
`93`	`93`	`private readonly Model _currentVocab;`
`94`	`94`	`private static Dictionary<string, WeakReference<Model>> _vocab = new Dictionary<string, WeakReference<Model>>();`
`95`	`95`
`96`		`- /// <summary>`
`97`		`- /// The names of the output and input column pairs on which the transformation is applied.`
`98`		`- /// </summary>`
`99`		`- private IReadOnlyCollection<(string outputColumnName, string inputColumnName)> Columns => ColumnPairs.AsReadOnly();`
`100`		`-`
`101`	`96`	`private sealed class Model`
`102`	`97`	`{`
`103`	`98`	`public readonly BigArray<float> WordVectors;`
`@@ -335,7 +330,7 @@ protected override DataViewSchema.DetachedColumn[] GetOutputColumnsCore()`
`335`	`330`
`336`	`331`	`public void SaveAsOnnx(OnnxContext ctx)`
`337`	`332`	`{`
`338`		`- foreach (var (outputColumnName, inputColumnName) in _parent.Columns)`
	`333`	`+ foreach (var (outputColumnName, inputColumnName) in _parent.ColumnPairs)`
`339`	`334`	`{`
`340`	`335`	`var srcVariableName = ctx.GetVariableName(inputColumnName);`
`341`	`336`	`var schema = _parent.GetOutputSchema(InputSchema);`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ internal static MLContext CreateRankingEnvironment<TEvaluator, TLoader, TTransfo`
`41`	`41`	`environment.ComponentCatalog.RegisterAssembly(typeof(TTransformer).Assembly);`
`42`	`42`	`environment.ComponentCatalog.RegisterAssembly(typeof(TTrainer).Assembly);`
`43`	`43`
`44`		`- environment.ComponentCatalog.RegisterAssembly(typeof(MissingValueDroppingTransformer).Assembly);`
	`44`	`+ environment.ComponentCatalog.RegisterAssembly(typeof(OneHotEncodingTransformer).Assembly);`
`45`	`45`
`46`	`46`	`return ctx;`
`47`	`47`	`}`