SgdCalibrated(
this SweepableBinaryClassificationTrainers trainer,
string labelColumnName = "Label",
string featureColumnName = "Features",
SweepableOption <SgdCalibratedTrainer.Options> optionBuilder = null,
SgdCalibratedTrainer.Options defaultOption = null)
{
var context = trainer.Context;
if (optionBuilder == null)
{
optionBuilder = SgdCalibratedBinaryTrainerSweepableOptions.Default;
}
optionBuilder.SetDefaultOption(defaultOption);
return(context.AutoML().CreateSweepableEstimator(
(context, option) =>
{
option.LabelColumnName = labelColumnName;
option.FeatureColumnName = featureColumnName;
return context.BinaryClassification.Trainers.SgdCalibrated(option);
},
optionBuilder,
new string[] { labelColumnName, featureColumnName },
new string[] { PredictedLabel },
nameof(SgdCalibratedTrainer)));
}
/// <summary>
/// Predict a target using logistic regression trained with the <see cref="SgdCalibratedTrainer"/> trainer.
/// </summary>
/// <param name="catalog">The binary classification catalog trainer object.</param>
/// <param name="label">The name of the label column.</param>
/// <param name="features">The name of the feature column.</param>
/// <param name="weights">The name for the example weight column.</param>
/// <param name="options">Advanced arguments to the algorithm.</param>
/// <param name="onFit">A delegate that is called every time the
/// <see cref="Estimator{TTupleInShape, TTupleOutShape, TTransformer}.Fit(DataView{TTupleInShape})"/> method is called on the
/// <see cref="Estimator{TTupleInShape, TTupleOutShape, 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> score, Scalar <float> probability, Scalar <bool> predictedLabel) StochasticGradientDescentClassificationTrainer(
this BinaryClassificationCatalog.BinaryClassificationTrainers catalog,
Scalar <bool> label,
Vector <float> features,
Scalar <float> weights,
SgdCalibratedTrainer.Options options,
Action <CalibratedModelParametersBase <LinearBinaryModelParameters, PlattCalibrator> > onFit = null)
{
var rec = new TrainerEstimatorReconciler.BinaryClassifier(
(env, labelName, featuresName, weightsName) =>
{
options.FeatureColumnName = featuresName;
options.LabelColumnName = labelName;
options.ExampleWeightColumnName = weightsName;
var trainer = new SgdCalibratedTrainer(env, options);
if (onFit != null)
{
return(trainer.WithOnFitDelegate(trans => onFit(trans.Model)));
}
return(trainer);
}, label, features, weights);
return(rec.Output);
}
// In this examples we will use the adult income dataset. The goal is to predict
// if a person's income is above $50K or not, based on demographic information about that person.
// For more details about this dataset, please see https://archive.ics.uci.edu/ml/datasets/adult.
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);
// Download and featurize the dataset.
var data = SamplesUtils.DatasetUtils.LoadFeaturizedAdultDataset(mlContext);
// Leave out 10% of data for testing.
var trainTestData = mlContext.Data.TrainTestSplit(data, testFraction: 0.1);
// Define the trainer options.
var options = new SgdCalibratedTrainer.Options()
{
// Make the convergence tolerance tighter.
ConvergenceTolerance = 5e-5,
// Increase the maximum number of passes over training data.
NumberOfIterations = 30,
// Give the instances of the positive class slightly more weight.
PositiveInstanceWeight = 1.2f,
};
// Create data training pipeline.
var pipeline = mlContext.BinaryClassification.Trainers.SgdCalibrated(options);
// Fit this pipeline to the training data.
var model = pipeline.Fit(trainTestData.TrainSet);
// Evaluate how the model is doing on the test data.
var dataWithPredictions = model.Transform(trainTestData.TestSet);
var metrics = mlContext.BinaryClassification.Evaluate(dataWithPredictions);
SamplesUtils.ConsoleUtils.PrintMetrics(metrics);
// Expected output:
// Accuracy: 0.85
// AUC: 0.90
// F1 Score: 0.67
// Negative Precision: 0.91
// Negative Recall: 0.89
// Positive Precision: 0.65
// Positive Recall: 0.70
// LogLoss: 0.48
// LogLossReduction: 37.52
// Entropy: 0.78
}
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 SgdCalibratedTrainer.Options()
{
// Make the convergence tolerance tighter.
ConvergenceTolerance = 5e-5,
// Increase the maximum number of passes over training data.
NumberOfIterations = 30,
// Give the instances of the positive class slightly more weight.
PositiveInstanceWeight = 1.2f,
};
// Define the trainer.
var pipeline = mlContext.BinaryClassification.Trainers
.SgdCalibrated(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();
// Print 5 predictions.
foreach (var p in predictions.Take(5))
{
Console.WriteLine($"Label: {p.Label}, "
+ $"Prediction: {p.PredictedLabel}");
}
// Expected output:
// Label: True, Prediction: False
// Label: False, Prediction: False
// Label: True, Prediction: True
// Label: True, Prediction: True
// Label: False, Prediction: False
// Evaluate the overall metrics.
var metrics = mlContext.BinaryClassification
.Evaluate(transformedTestData);
PrintMetrics(metrics);
// Expected output:
// Accuracy: 0.60
// AUC: 0.65
// F1 Score: 0.50
// Negative Precision: 0.59
// Negative Recall: 0.74
// Positive Precision: 0.61
// Positive Recall: 0.43
//
// TEST POSITIVE RATIO: 0.4760 (238.0/(238.0+262.0))
// Confusion table
// ||======================
// PREDICTED || positive | negative | Recall
// TRUTH ||======================
// positive || 184 | 54 | 0.7731
// negative || 156 | 106 | 0.4046
// ||======================
// Precision || 0.5412 | 0.6625 |
}