fixing the C#api and the entrypoints list.

attempt to fix the reference to intrinsics

Author: sfilipi

src/Microsoft.ML.StandardLearners/FactorizationMachine/FactorizationMachineInterface.cs

@@ -12,7 +12,7 @@ namespace Microsoft.ML.Runtime.FactorizationMachine
 {
     internal unsafe static class FieldAwareFactorizationMachineInterface
     {
-        internal const string NativePath = "FactorizationMachineNative.dll";
+        internal const string NativePath = "FactorizationMachineNative";
         public const int CbAlign = 16;
 
         private static bool Compat(AlignedArray a)

src/Microsoft.ML/CSharpApi.cs

@@ -478,6 +478,18 @@ public void Add(Microsoft.ML.Trainers.FastTreeTweedieRegressor input, Microsoft.
                 _jsonNodes.Add(Serialize("Trainers.FastTreeTweedieRegressor", input, output));
             }
 
+            public Microsoft.ML.Trainers.FieldAwareFactorizationMachineBinaryClassifier.Output Add(Microsoft.ML.Trainers.FieldAwareFactorizationMachineBinaryClassifier input)
+            {
+                var output = new Microsoft.ML.Trainers.FieldAwareFactorizationMachineBinaryClassifier.Output();
+                Add(input, output);
+                return output;
+            }
+
+            public void Add(Microsoft.ML.Trainers.FieldAwareFactorizationMachineBinaryClassifier input, Microsoft.ML.Trainers.FieldAwareFactorizationMachineBinaryClassifier.Output output)
+            {
+                _jsonNodes.Add(Serialize("Trainers.FieldAwareFactorizationMachineBinaryClassifier", input, output));
+            }
+
             public Microsoft.ML.Trainers.GeneralizedAdditiveModelBinaryClassifier.Output Add(Microsoft.ML.Trainers.GeneralizedAdditiveModelBinaryClassifier input)
             {
                 var output = new Microsoft.ML.Trainers.GeneralizedAdditiveModelBinaryClassifier.Output();
@@ -5987,6 +5999,130 @@ public FastTreeTweedieRegressorPipelineStep(Output output)
         }
     }
 
+    namespace Trainers
+    {
+
+        /// <summary>
+        /// Train a field-aware factorization machine for binary classification
+        /// </summary>
+        public sealed partial class FieldAwareFactorizationMachineBinaryClassifier : Microsoft.ML.Runtime.EntryPoints.CommonInputs.ITrainerInputWithLabel, Microsoft.ML.Runtime.EntryPoints.CommonInputs.ITrainerInput, Microsoft.ML.ILearningPipelineItem
+        {
+
+
+            /// <summary>
+            /// Initial learning rate
+            /// </summary>
+            [TlcModule.SweepableFloatParamAttribute("LearningRate", 0.001f, 1f, isLogScale:true)]
+            public float LearningRate { get; set; } = 0.1f;
+
+            /// <summary>
+            /// Number of training iterations
+            /// </summary>
+            [TlcModule.SweepableLongParamAttribute("Iters", 1, 100)]
+            public int Iters { get; set; } = 5;
+
+            /// <summary>
+            /// Latent space dimension
+            /// </summary>
+            [TlcModule.SweepableLongParamAttribute("LatentDim", 4, 100)]
+            public int LatentDim { get; set; } = 20;
+
+            /// <summary>
+            /// Regularization coefficient of linear weights
+            /// </summary>
+            [TlcModule.SweepableFloatParamAttribute("LambdaLinear", 1E-08f, 1f, isLogScale:true)]
+            public float LambdaLinear { get; set; } = 0.0001f;
+
+            /// <summary>
+            /// Regularization coefficient of latent weights
+            /// </summary>
+            [TlcModule.SweepableFloatParamAttribute("LambdaLatent", 1E-08f, 1f, isLogScale:true)]
+            public float LambdaLatent { get; set; } = 0.0001f;
+
+            /// <summary>
+            /// Whether to normalize the input vectors so that the concatenation of all fields' feature vectors is unit-length
+            /// </summary>
+            public bool Norm { get; set; } = true;
+
+            /// <summary>
+            /// Whether to shuffle for each training iteration
+            /// </summary>
+            public bool Shuffle { get; set; } = true;
+
+            /// <summary>
+            /// Report traning progress or not
+            /// </summary>
+            public bool Verbose { get; set; } = true;
+
+            /// <summary>
+            /// Radius of initial latent factors
+            /// </summary>
+            [TlcModule.SweepableFloatParamAttribute("Radius", 0.1f, 1f)]
+            public float Radius { get; set; } = 0.5f;
+
+            /// <summary>
+            /// Column to use for labels
+            /// </summary>
+            public string LabelColumn { get; set; } = "Label";
+
+            /// <summary>
+            /// The data to be used for training
+            /// </summary>
+            public Var<Microsoft.ML.Runtime.Data.IDataView> TrainingData { get; set; } = new Var<Microsoft.ML.Runtime.Data.IDataView>();
+
+            /// <summary>
+            /// Column to use for features
+            /// </summary>
+            public string FeatureColumn { get; set; } = "Features";
+
+            /// <summary>
+            /// Normalize option for the feature column
+            /// </summary>
+            public Microsoft.ML.Models.NormalizeOption NormalizeFeatures { get; set; } = Microsoft.ML.Models.NormalizeOption.Auto;
+
+            /// <summary>
+            /// Whether learner should cache input training data
+            /// </summary>
+            public Microsoft.ML.Models.CachingOptions Caching { get; set; } = Microsoft.ML.Models.CachingOptions.Auto;
+
+
+            public sealed class Output : Microsoft.ML.Runtime.EntryPoints.CommonOutputs.IBinaryClassificationOutput, Microsoft.ML.Runtime.EntryPoints.CommonOutputs.ITrainerOutput
+            {
+                /// <summary>
+                /// The trained model
+                /// </summary>
+                public Var<Microsoft.ML.Runtime.EntryPoints.IPredictorModel> PredictorModel { get; set; } = new Var<Microsoft.ML.Runtime.EntryPoints.IPredictorModel>();
+
+            }
+            public Var<IDataView> GetInputData() => TrainingData;
+            
+            public ILearningPipelineStep ApplyStep(ILearningPipelineStep previousStep, Experiment experiment)
+            {
+                if (previousStep != null)
+                {
+                    if (!(previousStep is ILearningPipelineDataStep dataStep))
+                    {
+                        throw new InvalidOperationException($"{ nameof(FieldAwareFactorizationMachineBinaryClassifier)} only supports an { nameof(ILearningPipelineDataStep)} as an input.");
+                    }
+
+                    TrainingData = dataStep.Data;
+                }
+                Output output = experiment.Add(this);
+                return new FieldAwareFactorizationMachineBinaryClassifierPipelineStep(output);
+            }
+
+            private class FieldAwareFactorizationMachineBinaryClassifierPipelineStep : ILearningPipelinePredictorStep
+            {
+                public FieldAwareFactorizationMachineBinaryClassifierPipelineStep(Output output)
+                {
+                    Model = output.PredictorModel;
+                }
+
+                public Var<IPredictorModel> Model { get; }
+            }
+        }
+    }
+
     namespace Trainers
     {
 

src/Native/FactorizationMachineNative/CMakeLists.txt

@@ -7,7 +7,6 @@ set(SOURCES
 
 if(WIN32)
 else()
-    set_property(SOURCE segment.cpp APPEND_STRING PROPERTY COMPILE_FLAGS " -msse4.1")
     list(APPEND SOURCES ${VERSION_FILE_PATH})
 endif()
 

src/Native/FactorizationMachineNative/FactorizationMachineCore.cpp

@@ -2,20 +2,11 @@
 #include <cstring>
 #include <limits>
 #include <pmmintrin.h>
+#include "../Stdafx.h"
 
 #define UNUSED(x) (void)(x)
 #define DEBUG_ONLY(x) (void)(x)
 
-#ifdef COMPILER_GCC
-
-#include "UnixSal.h"
-#define EXPORT_API(ret) extern "C" __attribute__((visibility("default"))) ret
-
-#else
-#include <intrin.h>
-#define EXPORT_API(ret) extern "C" __declspec(dllexport) ret __stdcall
-#endif
-
 EXPORT_API(void) CalculateIntermediateVariablesNative(int fieldCount, int latentDim, int count, _In_ int * fieldIndices, _In_ int * featureIndices, _In_ float * featureValues,
     _In_ float * linearWeights, _In_ float * latentWeights, _Inout_ float * latentSum, _Out_ float * response)
 {

test/BaselineOutput/Common/EntryPoints/core_ep-list.tsv

@@ -36,6 +36,7 @@ Trainers.FastTreeBinaryClassifier	Uses a logit-boost boosted tree learner to per
 Trainers.FastTreeRanker	Trains gradient boosted decision trees to the LambdaRank quasi-gradient.	Microsoft.ML.Runtime.FastTree.FastTree	TrainRanking	Microsoft.ML.Runtime.FastTree.FastTreeRankingTrainer+Arguments	Microsoft.ML.Runtime.EntryPoints.CommonOutputs+RankingOutput
 Trainers.FastTreeRegressor	Trains gradient boosted decision trees to fit target values using least-squares.	Microsoft.ML.Runtime.FastTree.FastTree	TrainRegression	Microsoft.ML.Runtime.FastTree.FastTreeRegressionTrainer+Arguments	Microsoft.ML.Runtime.EntryPoints.CommonOutputs+RegressionOutput
 Trainers.FastTreeTweedieRegressor	Trains gradient boosted decision trees to fit target values using a Tweedie loss function. This learner is a generalization of Poisson, compound Poisson, and gamma regression.	Microsoft.ML.Runtime.FastTree.FastTree	TrainTweedieRegression	Microsoft.ML.Runtime.FastTree.FastTreeTweedieTrainer+Arguments	Microsoft.ML.Runtime.EntryPoints.CommonOutputs+RegressionOutput
+Trainers.FieldAwareFactorizationMachineBinaryClassifier	Train a field-aware factorization machine for binary classification	Microsoft.ML.Runtime.FactorizationMachine.FieldAwareFactorizationMachineTrainer	TrainBinary	Microsoft.ML.Runtime.FactorizationMachine.FieldAwareFactorizationMachineTrainer+Arguments	Microsoft.ML.Runtime.EntryPoints.CommonOutputs+BinaryClassificationOutput
 Trainers.GeneralizedAdditiveModelBinaryClassifier	Trains a gradient boosted stump per feature, on all features simultaneously, to fit target values using least-squares. It mantains no interactions between features.	Microsoft.ML.Runtime.FastTree.Gam	TrainBinary	Microsoft.ML.Runtime.FastTree.BinaryClassificationGamTrainer+Arguments	Microsoft.ML.Runtime.EntryPoints.CommonOutputs+BinaryClassificationOutput
 Trainers.GeneralizedAdditiveModelRegressor	Trains a gradient boosted stump per feature, on all features simultaneously, to fit target values using least-squares. It mantains no interactions between features.	Microsoft.ML.Runtime.FastTree.Gam	TrainRegression	Microsoft.ML.Runtime.FastTree.RegressionGamTrainer+Arguments	Microsoft.ML.Runtime.EntryPoints.CommonOutputs+RegressionOutput
 Trainers.KMeansPlusPlusClusterer	K-means is a popular clustering algorithm. With K-means, the data is clustered into a specified number of clusters in order to minimize the within-cluster sum of squares. K-means++ improves upon K-means by using a better method for choosing the initial cluster centers.	Microsoft.ML.Runtime.KMeans.KMeansPlusPlusTrainer	TrainKMeans	Microsoft.ML.Runtime.KMeans.KMeansPlusPlusTrainer+Arguments	Microsoft.ML.Runtime.EntryPoints.CommonOutputs+ClusteringOutput