/// <summary> /// Predict a target using a linear regression model trained with the <see cref="OnlineGradientDescentTrainer"/> trainer. /// </summary> /// <param name="catalog">The regression catalog trainer object.</param> /// <param name="label">The label, or dependent variable.</param> /// <param name="features">The features, or independent variables.</param> /// <param name="weights">The optional example weights.</param> /// <param name="options">Advanced arguments to the algorithm.</param> /// <param name="onFit">A delegate that is called every time the /// <see cref="Estimator{TInShape, TOutShape, TTransformer}.Fit(DataView{TInShape})"/> method is called on the /// <see cref="Estimator{TInShape, TOutShape, TTransformer}"/> instance created out of this. This delegate will receive /// the linear model that was trained, as well as the calibrator on top of that model. Note that this action cannot change the /// result in any way; it is only a way for the caller to be informed about what was learnt.</param> /// <returns>The set of output columns including in order the predicted binary classification score (which will range /// from negative to positive infinity), and the predicted label.</returns> /// <seealso cref="OnlineGradientDescentTrainer"/>. /// <returns>The predicted output.</returns> public static Scalar <float> OnlineGradientDescent(this RegressionCatalog.RegressionTrainers catalog, Scalar <float> label, Vector <float> features, Scalar <float> weights, OnlineGradientDescentTrainer.Options options, Action <LinearRegressionModelParameters> onFit = null) { Contracts.CheckValue(label, nameof(label)); Contracts.CheckValue(features, nameof(features)); Contracts.CheckValueOrNull(weights); Contracts.CheckValue(options, nameof(options)); Contracts.CheckValueOrNull(onFit); var rec = new TrainerEstimatorReconciler.Regression( (env, labelName, featuresName, weightsName) => { options.LabelColumnName = labelName; options.FeatureColumnName = featuresName; var trainer = new OnlineGradientDescentTrainer(env, options); if (onFit != null) { return(trainer.WithOnFitDelegate(trans => onFit(trans.Model))); } return(trainer); }, label, features, weights); return(rec.Score); }
OnlineGradientDescent( this SweepableRegressionTrainers trainers, string labelColumnName = "Label", string featureColumnName = "Features", SweepableOption <OnlineGradientDescentTrainer.Options> optionSweeper = null, OnlineGradientDescentTrainer.Options defaultOption = null) { var context = trainers.Context; if (optionSweeper == null) { optionSweeper = OnlineGradientDescentTrainerSweepableOptions.Default; } optionSweeper.SetDefaultOption(defaultOption); return(context.AutoML().CreateSweepableEstimator( (context, option) => { option.LabelColumnName = labelColumnName; option.FeatureColumnName = featureColumnName; return context.Regression.Trainers.OnlineGradientDescent(option); }, optionSweeper, new string[] { labelColumnName, featureColumnName }, new string[] { Score }, nameof(OnlineGradientDescentTrainer))); }
public static void Example() { // Create a new context for ML.NET operations. It can be used for exception tracking and logging, // as a catalog of available operations and as the source of randomness. // Setting the seed to a fixed number in this example to make outputs deterministic. var mlContext = new MLContext(seed: 0); // Create a list of training data points. var dataPoints = GenerateRandomDataPoints(1000); // Convert the list of data points to an IDataView object, which is consumable by ML.NET API. var trainingData = mlContext.Data.LoadFromEnumerable(dataPoints); // Define trainer options. var options = new OnlineGradientDescentTrainer.Options { LabelColumnName = nameof(DataPoint.Label), FeatureColumnName = nameof(DataPoint.Features), // Change the loss function. LossFunction = new TweedieLoss(), // Give an extra gain to more recent updates. RecencyGain = 0.1f, // Turn off lazy updates. LazyUpdate = false, // Specify scale for initial weights. InitialWeightsDiameter = 0.2f }; // Define the trainer. var pipeline = mlContext.Regression.Trainers.OnlineGradientDescent(options); // Train the model. var model = pipeline.Fit(trainingData); // Create testing data. Use different random seed to make it different from training data. var testData = mlContext.Data.LoadFromEnumerable(GenerateRandomDataPoints(5, seed: 123)); // Run the model on test data set. var transformedTestData = model.Transform(testData); // Convert IDataView object to a list. var predictions = mlContext.Data.CreateEnumerable <Prediction>(transformedTestData, reuseRowObject: false).ToList(); // Look at 5 predictions for the Label, side by side with the actual Label for comparison. foreach (var p in predictions) { Console.WriteLine($"Label: {p.Label:F3}, Prediction: {p.Score:F3}"); } // This trainer is not numerically stable. Please see issue #2425. // Evaluate the overall metrics var metrics = mlContext.Regression.Evaluate(transformedTestData); PrintMetrics(metrics); // This trainer is not numerically stable. Please see issue #2425. }
/// <summary> /// Predict a target using a linear regression model trained with the <see cref="OnlineGradientDescentTrainer"/> trainer. /// </summary> /// <param name="catalog">The regression catalog trainer object.</param> /// <param name="options">Advanced arguments to the algorithm.</param> public static OnlineGradientDescentTrainer OnlineGradientDescent(this RegressionCatalog.RegressionTrainers catalog, OnlineGradientDescentTrainer.Options options) { Contracts.CheckValue(catalog, nameof(catalog)); Contracts.CheckValue(options, nameof(options)); var env = CatalogUtils.GetEnvironment(catalog); return(new OnlineGradientDescentTrainer(env, options)); }
public static PredictionEngine <TIn, TOut> OnlineGradientDescent <TIn, TOut>( IEnumerable <TIn> trainDataset, OnlineGradientDescentTrainer.Options options, Action <ITransformer> additionModelAction = null) where TIn : class, new() where TOut : class, new() { var context = new MLContext(); var model = context.RegressionTrainerTemplate(trainDataset, context.Regression.Trainers.OnlineGradientDescent(options)); var predictionEngine = context.Model.CreatePredictionEngine <TIn, TOut>(model); additionModelAction?.Invoke(model); return(predictionEngine); }