/// <summary>
/// Predict a target using a linear regression model trained with the <see cref="Microsoft.ML.Trainers.LogisticRegressionBinaryTrainer"/> 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. 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 predicted output.</returns>
public static Scalar <float> PoissonRegression(this RegressionCatalog.RegressionTrainers catalog,
Scalar <float> label,
Vector <float> features,
Scalar <float> weights,
PoissonRegressionTrainer.Options options,
Action <PoissonRegressionModelParameters> onFit = null)
{
Contracts.CheckValue(label, nameof(label));
Contracts.CheckValue(features, nameof(features));
Contracts.CheckValue(options, nameof(options));
Contracts.CheckValueOrNull(onFit);
var rec = new TrainerEstimatorReconciler.Regression(
(env, labelName, featuresName, weightsName) =>
{
options.LabelColumnName = labelName;
options.FeatureColumnName = featuresName;
options.ExampleWeightColumnName = weightsName;
var trainer = new PoissonRegressionTrainer(env, options);
if (onFit != null)
{
return(trainer.WithOnFitDelegate(trans => onFit(trans.Model)));
}
return(trainer);
}, label, features, weights);
return(rec.Score);
}
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 PoissonRegressionTrainer.Options
{
// Reduce optimization tolerance to speed up training at the cost of accuracy.
OptmizationTolerance = 1e-4f,
// Decrease history size to speed up training at the cost of accuracy.
HistorySize = 30,
// Specify scale for initial weights.
InitialWeightsDiameter = 0.2f
};
// Define the trainer.
var pipeline = mlContext.Regression.Trainers.PoissonRegression(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(500, 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
foreach (var p in predictions.Take(5))
Console.WriteLine($"Label: {p.Label:F3}, Prediction: {p.Score:F3}");
// Expected output:
// Label: 0.985, Prediction: 1.110
// Label: 0.155, Prediction: 0.169
// Label: 0.515, Prediction: 0.400
// Label: 0.566, Prediction: 0.415
// Label: 0.096, Prediction: 0.169
// Evaluate the overall metrics
var metrics = mlContext.Regression.Evaluate(transformedTestData);
SamplesUtils.ConsoleUtils.PrintMetrics(metrics);
// Expected output:
// Mean Absolute Error: 0.07
// Mean Squared Error: 0.01
// Root Mean Squared Error: 0.09
// RSquared: 0.90
}
