public static void PrintRegressionMetrics(RegressionMetrics metrics)
{
Console.WriteLine($"*************************************************");
Console.WriteLine($"* Metrics for Regression model ");
Console.WriteLine($"*------------------------------------------------");
Console.WriteLine($"* LossFn: {metrics.LossFunction:0.##}");
Console.WriteLine($"* R2 Score: {metrics.RSquared:0.##}");
Console.WriteLine($"* Absolute loss: {metrics.MeanAbsoluteError:#.##}");
Console.WriteLine($"* Squared loss: {metrics.MeanSquaredError:#.##}");
Console.WriteLine($"* RMS loss: {metrics.RootMeanSquaredError:#.##}");
Console.WriteLine($"*************************************************");
}
//(CDLTLL-Pending to Fix - Results --> ?)
//
public static void PrintRegressionMetrics(string name, RegressionMetrics metrics)
{
Console.WriteLine($"*************************************************");
Console.WriteLine($"* Metrics for {name} regression model ");
Console.WriteLine($"*------------------------------------------------");
Console.WriteLine($"* LossFn: {metrics.LossFn:0.##}");
Console.WriteLine($"* R2 Score: {metrics.RSquared:0.##}");
Console.WriteLine($"* Absolute loss: {metrics.L1:#.##}");
Console.WriteLine($"* Squared loss: {metrics.L2:#.##}");
Console.WriteLine($"* RMS loss: {metrics.Rms:#.##}");
Console.WriteLine($"*************************************************");
}
public static void DisplayMetrics(string datasetName, RegressionMetrics metrics)
{
if (metrics == null)
{
Console.WriteLine("Task 4 \"Evaluate model\" not completed.\n");
}
else
{
Console.WriteLine("Metrics from " + datasetName + " data");
Console.WriteLine("Mean Absolute Error : " + metrics.MeanAbsoluteError.ToString());
Console.WriteLine("RSquared: " + metrics.RSquared.ToString() + "\n");
}
}
private static void Evaluate(PredictionModel <TaxiTrip, TaxiTripFarePrediction> model)
{
var textData = new TextLoader <TaxiTrip>(TestDataPath, useHeader: true, separator: ",");
var evaluator = new RegressionEvaluator();
RegressionMetrics matrics = evaluator.Evaluate(model, textData);
Console.WriteLine("Rms=" + matrics.Rms);
Console.WriteLine("RSquared=" + matrics.RSquared);
TaxiTripFarePrediction prediction01 = model.Predict(TestTrips.Trip1);
Console.WriteLine("Predict fare : {0}, actual fare : 29.5", prediction01.fare_amount);
}
double GetRSquared(IEstimator <ITransformer> pipeline)
{
DataOperationsCatalog.TrainTestData dataSplit = MlContext.Data.TrainTestSplit(AllData, testFraction: 0.2);
IDataView trainData = dataSplit.TrainSet;
IDataView testData = dataSplit.TestSet;
var model = pipeline.Fit(trainData);
IDataView transformedData = model.Transform(testData);
RegressionMetrics metrics = MlContext.Regression.Evaluate(transformedData);
return(metrics.RSquared);
}
public PowerballPrediction PredictPowerball()
{
var pipeline = new LearningPipeline();
var allPicks = _ctx.Powerballs;
var data = new List <PowerballData>();
foreach (var powerball in allPicks)
{
var ts = powerball.draw_date - DateTime.Now;
var newPick = new PowerballData()
{
Ball1 = Convert.ToInt32(powerball.ball1),
Ball2 = Convert.ToInt32(powerball.ball2),
Ball3 = Convert.ToInt32(powerball.ball3),
Ball4 = Convert.ToInt32(powerball.ball4),
Ball5 = Convert.ToInt32(powerball.ball5),
PowerBall = Convert.ToInt32(powerball.powerball),
daysAgo = (float)ts.TotalDays
};
data.Add(newPick);
}
var collection = CollectionDataSource.Create(data);
pipeline.Add(collection);
pipeline.Add(new ColumnCopier(("daysAgo", "Label")));
pipeline.Add(new CategoricalOneHotVectorizer("id"));
pipeline.Add(new ColumnConcatenator("Features", "id", "daysAgo"));
pipeline.Add(new FastTreeRegressor());
var model = pipeline.Train <PowerballData, PowerballPrediction>();
var eval = new RegressionEvaluator();
RegressionMetrics metrics = eval.Evaluate(model, collection);
Console.WriteLine($"Rms = {metrics.Rms}");
Console.WriteLine($"RSquared = {metrics.RSquared}");
var nextPowerball = _ctx.NextPowerball.FirstOrDefault();
var predictedDays = (nextPowerball.next_jackpot_date.AddDays(1)) - DateTime.Now;
var prediction = model.Predict(new PowerballData()
{
Ball1 = 0, Ball2 = 0, Ball3 = 0, Ball4 = 0, Ball5 = 0, PowerBall = 0, daysAgo = predictedDays.Days
});
return(prediction);
}
private static void Evaluate(PredictionModel <TaxiTrip, TaxiTripFarePredition> model)
{
var testData = new TextLoader(_testdatapath).CreateFrom <TaxiTrip>(useHeader: true, separator: ',');
var evaluator = new RegressionEvaluator();
RegressionMetrics metrics = evaluator.Evaluate(model, testData);
// Rms is one of the evaluation metrics of the regression model. The lower it is, the better
Console.WriteLine($"Rms = {metrics.Rms}");
// RSquared is another evaluation metric of the regression mode. RSquared takes values between 0 and 1. The
// closer its value is to 1, the better the model is.
Console.WriteLine($"RSquared = {metrics.RSquared}");
}
private static void Evaluate(PredictionModel <TaxiTrip, TaxiTripFarePrediction> model)
{
// Load test data
var testData = new TextLoader(_datapath).CreateFrom <TaxiTrip>(useHeader: true, separator: ',');
// Evaluate test data
var evaluator = new RegressionEvaluator();
RegressionMetrics metrics = evaluator.Evaluate(model, testData);
// Display regression evaluation metrics
// Rms should be around 2.795276
Console.WriteLine("Rms=" + metrics.Rms);
Console.WriteLine("RSquared = " + metrics.RSquared);
}
public static string Evaluate(PredictionModel <ApartmentData, AppartmentPricePrediction> model)
{
// Load the test data from a file
var testData = new TextLoader(TEST_DATA_PATH).CreateFrom <ApartmentData>(separator: ',');
// Make an evaluator matrix
var evaluator = new RegressionEvaluator();
RegressionMetrics metrics = evaluator.Evaluate(model, testData);
// Print the RMS and RSquared are evaluation matrixes of the regression model
// RMS: The lower it is, the better the model is
// RSquared: takes values between 0 and 1. The closer its value is to 1, the better the model is.
return($"Rms = {metrics.Rms}" + $", RSquared = {metrics.RSquared}");
}
public static RegressionMetrics Evaluate(Observation[] actual, Observation[] forecast)
{
IEnumerable <Comparison> comparisons = BuildComparisons(actual, forecast);
var context = new MLContext();
IDataView predictions = context.Data.LoadFromEnumerable(comparisons);
RegressionMetrics regressionMetrics = context.Regression.Evaluate(
data: predictions,
labelColumnName: nameof(Comparison.Actual),
scoreColumnName: nameof(Comparison.Predicted));
return(regressionMetrics);
}
private static void Evaluate(PredictionModel <RandomFone, Predict> model)
{
try
{
var testData = new TextLoader <RandomFone>(TestDataPath, useHeader: true, separator: ",");
var evaluator = new RegressionEvaluator();
RegressionMetrics metrics = evaluator.Evaluate(model, testData);
Console.WriteLine("Rms=" + metrics.Rms);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
/// <summary>
/// 评估模型
/// </summary>
/// <param name="model"></param>
public static void Evaluate(IEnumerable <JiaMiTu> testData, PredictionModel <JiaMiTu, JiaMiTuPrediction> model)
{
//var testData = new TextLoader<JiaMiTu>(TestDataPath, useHeader: true, separator: ",");
var test = CollectionDataSource.Create(testData);
var evaluator = new RegressionEvaluator();
RegressionMetrics metrics = evaluator.Evaluate(model, test);
// Rms should be around 2.795276
//RMS是评估回归问题的一个指标。它越低，你的模型就越好。将以下代码添加到该Evaluate()函数中以打印模型的RMS。
Console.WriteLine("Rms=" + metrics.Rms);
Console.WriteLine("LossFn=" + metrics.LossFn);
//Squared是评估回归问题的另一个指标。RSquared将是介于0和1之间的值。越接近1，模型越好。将下面的代码添加到该Evaluate()函数中以打印模型的RSquared值。
Console.WriteLine("RSquared = " + metrics.RSquared);
}
public static void Metrics(RegressionMetrics metrics)
{
ConsoleHelper.WriteLines(new[]
{
$"--------------------------------------------------",
$" Metrics ",
$"--------------------------------------------------",
$" LossFn: {metrics.LossFunction,10:N2}",
$" R2 Score: {metrics.RSquared,10:N2}",
$" Absolute loss: {metrics.MeanAbsoluteError,10:N2}",
$" Squared loss: {metrics.MeanSquaredError,10:N2}",
$" RMS loss: {metrics.RootMeanSquaredError,10:N2}",
$"--------------------------------------------------"
}, ConsoleColor.Green);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World 'Microsoft.ML'!");
List <FormulaData> pointsValues = Enumerable
.Range(-1, 100)
.Select(value => { return(new FormulaData(value, value * 2 - 1)); })
.ToList();
// Create MLContext
var mlContext = new MLContext(1);
// Load Data
IDataView data = mlContext.Data.LoadFromEnumerable <FormulaData>(pointsValues);
DataOperationsCatalog.TrainTestData dataSplit = mlContext.Data.TrainTestSplit(data, testFraction: 0.2);
IDataView trainData = dataSplit.TrainSet;
IDataView testData = dataSplit.TestSet;
// Define trainer options.
var options = new SdcaRegressionTrainer.Options
{
LabelColumnName = "Label", //nameof(FormulaData.Y),
FeatureColumnName = "Features", //nameof(FormulaData.X),
// Make the convergence tolerance tighter. It effectively leads to more training iterations.
ConvergenceTolerance = 0.02f,
// Increase the maximum number of passes over training data. Similar to ConvergenceTolerance,
// this value specifics the hard iteration limit on the training algorithm.
MaximumNumberOfIterations = 30,
// Increase learning rate for bias.
BiasLearningRate = 0.1f
};
// Define StochasticDualCoodrinateAscent regression algorithm estimator
var sdcaEstimator = mlContext.Regression.Trainers.Sdca(options);
// Build machine learning model
var trainedModel = sdcaEstimator.Fit(trainData);
// Use trained model to make inferences on test data
IDataView testDataPredictions = trainedModel.Transform(testData);
// Extract model metrics and get RSquared
RegressionMetrics trainedModelMetrics = mlContext.Regression.Evaluate(testDataPredictions);
double rSquared = trainedModelMetrics.RSquared;
Console.WriteLine($"rSquared: {rSquared}");
}
private static void Evaluate(PredictionModel <TaxiTrip, TaxiTripFarePrediction> model)
{
var testData = new TextLoader(_testdatapath).CreateFrom <TaxiTrip>(useHeader: true, separator: ',');
var evaluator = new RegressionEvaluator();
RegressionMetrics metrics = evaluator.Evaluate(model, testData);
Console.WriteLine($"RMS = {metrics.Rms}");
Console.WriteLine($"RSquared = {metrics.RSquared}");
// Using the model for predictions
TaxiTripFarePrediction prediction = model.Predict(TestTrip.Trip1);
Console.WriteLine($"Predicted fare: {prediction.FareAmount}, actual fare: 29.5");
}
public void PrintRegressionMetrics(RegressionMetrics metrics)
{
using (StringWriter s = new StringWriter())
{
s.Write($"\r\n" + ResourcesUtils.GetMessage("mac_lrn_bldr_reg_metrics_1"));
s.Write($"\r\n" + ResourcesUtils.GetMessage("mac_lrn_bldr_reg_metrics_2"));
s.Write($"\r\n" + ResourcesUtils.GetMessage("mac_lrn_bldr_reg_metrics_3"));
s.Write($"\r\n" + ResourcesUtils.GetMessage("mac_lrn_bldr_reg_metrics_4") + $" {metrics.LossFunction:0.##}");
s.Write($"\r\n" + ResourcesUtils.GetMessage("mac_lrn_bldr_reg_metrics_5") + $" {metrics.RSquared:0.##}");
s.Write($"\r\n" + ResourcesUtils.GetMessage("mac_lrn_bldr_reg_metrics_6") + $" {metrics.MeanAbsoluteError:#.##}");
s.Write($"\r\n" + ResourcesUtils.GetMessage("mac_lrn_bldr_reg_metrics_7") + $" {metrics.MeanSquaredError:#.##}");
s.Write($"\r\n" + ResourcesUtils.GetMessage("mac_lrn_bldr_reg_metrics_8") + $" {metrics.RootMeanSquaredError:#.##}");
s.Write($"\r\n" + ResourcesUtils.GetMessage("mac_lrn_bldr_reg_metrics_1"));
InvokeProcessingStatus(s.ToString());
}
}
public void Entrenar()
{
List <InputData> lista = ModeloAprendizaje.Estructuras2List();
System.Console.WriteLine("Emprezando Entrenamiento: " + this.Descripcion());
IDataView dataview = mlContext.Data.LoadFromEnumerable <InputData>(lista);
//10% para testing
DataOperationsCatalog.TrainTestData dataSplit = mlContext.Data.TrainTestSplit(dataview, testFraction: _level);
IDataView trainData = dataSplit.TrainSet;
IDataView testData = dataSplit.TestSet;
IEstimator <ITransformer> dataPrepEstimator =
mlContext.Transforms.NormalizeMinMax("Features");
ITransformer dataPrepTransformer = dataPrepEstimator.Fit(trainData);
IDataView transformedTrainingData = dataPrepTransformer.Transform(trainData);
var sdcaEstimator = mlContext.Regression.Trainers.Sdca();
var trainedModel = sdcaEstimator.Fit(transformedTrainingData);
//TESTEO
// Measure trained model performance
// Apply data prep transformer to test data
IDataView transformedTestData = dataPrepTransformer.Transform(testData);
// Use trained model to make inferences on test data
IDataView testDataPredictions = trainedModel.Transform(transformedTestData);
// Extract model metrics and get RSquared
RegressionMetrics trainedModelMetrics = mlContext.Regression.Evaluate(testDataPredictions);
double rSquared = trainedModelMetrics.RSquared;
System.Console.WriteLine("ERROR {0}", rSquared);
string fichero = "Level" + (int)(_level * 100) + ".zip";
mlContext.Model.Save(trainedModel, dataview.Schema, fichero);
System.Console.WriteLine("Fin Entrenamiento: " + this.Descripcion());
}
public void Trainer()
{
var data = mlContext.Data.LoadFromTextFile <InsurerBillData>(trainingDataFilePath, separatorChar: ',', hasHeader: true);
var dataSplit = mlContext.Data.TrainTestSplit(data, testFraction: 0.2);
IDataView trainData = dataSplit.TrainSet;
IDataView testData = dataSplit.TestSet;
// Define Data Prep Estimator
// 1. Concatenate Size and Historical into a single feature vector output to a new column called Features
// 2. Normalize Features vector
IEstimator <ITransformer> dataPrepEstimator = mlContext.Transforms
.Concatenate("ChannelName", "ProductId", "DateSold", "SPV")
.Append(mlContext.Transforms.NormalizeMinMax("SPV"));
// Create data prep transformer
ITransformer dataPrepTransformer = dataPrepEstimator.Fit(trainData);
// Apply transforms to training data
IDataView transformedTrainingData = dataPrepTransformer.Transform(trainData);
// train model
// Define StochasticDualCoordinateAscent regression algorithm estimator
var sdcaEstimator = mlContext.Regression.Trainers.Sdca();
// Build machine learning model
var trainedModel = sdcaEstimator.Fit(transformedTrainingData);
var trainedModelParameters = trainedModel.Model as LinearRegressionModelParameters;
// Evaluate model quality
// Measure trained model performance
// Apply data prep transformer to test data
IDataView transformedTestData = dataPrepTransformer.Transform(testData);
// Use trained model to make inferences on test data
IDataView testDataPredictions = trainedModel.Transform(transformedTestData);
// Extract model metrics and get RSquared
RegressionMetrics trainedModelMetrics = mlContext.Regression.Evaluate(testDataPredictions);
double rSquared = trainedModelMetrics.RSquared;
// Save Trained Model
mlContext.Model.Save(trainedModel, data.Schema, "model.zip");
}
private void InitializeModel()
{
var mlContext = new MLContext(seed: 0);
if (File.Exists(_modelPath))
{
_trainedModel = mlContext.Model.Load(_modelPath, out DataViewSchema modelSchema);
}
else
{
var features = new string[] { "FGM", "FG3M", "FTM" };
_trainedModel = Train(features, saveModel: true);
}
Metrics = Evaluate(_trainedModel);
}
private static void PrintRegressionFoldsAverageMetrics(RegressionMetrics metrics)
{
var RMS = metrics.RootMeanSquaredError;
var lossFunction = metrics.LossFunction;
var R2 = metrics.RSquared;
Console.WriteLine(
$"*************************************************************************************************************");
Console.WriteLine($"* Metrics for Regression model ");
Console.WriteLine(
$"*------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"* Average RMS: {RMS:0.###} ");
Console.WriteLine($"* Average Loss Function: {lossFunction:0.###} ");
Console.WriteLine($"* Average R-squared: {R2:0.###} ");
Console.WriteLine(
$"*************************************************************************************************************");
}
public static ITransformer TrainModelWithData(MLContext context, TrainingData train, TrainingData validation,
out DataViewSchema inputSchema)
{
//var trainer = context.Regression.Trainers.FastForest();
//var trainer = context.Regression.Trainers.FastTreeTweedie();
var trainer = context.Regression.Trainers.LightGbm();
var trainingView = ToDataView(context, train);
inputSchema = trainingView.Schema;
var validationView = ToDataView(context, validation);
var transformer = validation != null?trainer.Fit(trainingView, validationView) : trainer.Fit(trainingView);
var predictions = transformer.Transform(validationView);
RegressionMetrics trainedModelMetrics = context.Regression.Evaluate(predictions);
Console.WriteLine("Validation loss = {0}", trainedModelMetrics.LossFunction);
return(transformer);
}
/// <summary>
/// 使用測試資料評估模型效能，以進行品質保證和驗證。
/// Evaluate 方法會執行下列工作：
/// * 載入測試資料集。
/// * 建立迴歸評估工具。
/// * 評估模型並建立計量。
/// * 顯示計量。
/// </summary>
/// <param name="mlContext"></param>
/// <param name="model"></param>
private static void Evaluate(MLContext mlContext, ITransformer model)
{
// 使用 LoadFromTextFile() 方法載入測試資料集。
IDataView dataView = mlContext.Data.LoadFromTextFile <TaxiTrip>(_testDataPath, hasHeader: true, separatorChar: ',');
//針對測試資料集輸入資料列進行預測
var predictions = model.Transform(dataView);
// 使用指定的資料集來計算 PredictionModel 的品質計量。 傳回的 RegressionMetrics 物件包含迴歸評估工具所計算的整體計量
RegressionMetrics metrics = mlContext.Regression.Evaluate(predictions, "Label", "Score");
Console.WriteLine();
Console.WriteLine($"*************************************************");
Console.WriteLine($"* 模型品質指標評估 ");
Console.WriteLine($"*------------------------------------------------");
Console.WriteLine($"* RSquared Score: {metrics.RSquared:0.##}");
Console.WriteLine($"* Root Mean Squared Error: {metrics.RootMeanSquaredError:#.##}");
}
static void Main(string[] args)
{
var context = new MLContext(seed: 0);
// Load the data
var data = context.Data.LoadFromTextFile <Input>(_path, hasHeader: true, separatorChar: ',');
// Create an experiment
var settings = new RegressionExperimentSettings
{
MaxExperimentTimeInSeconds = 600, // 10 minutes max
OptimizingMetric = RegressionMetric.RSquared,
CacheDirectory = null
};
var experiment = context.Auto().CreateRegressionExperiment(settings);
// Run the experiment
Console.WriteLine("Running the experiment...");
var result = experiment.Execute(data);
RegressionMetrics metrics = result.BestRun.ValidationMetrics;
Console.WriteLine($"R2 score: {metrics.RSquared:0.##}");
Console.WriteLine();
// Use the best model to make a prediction
var predictor = context.Model.CreatePredictionEngine <Input, Output>(result.BestRun.Model);
var input = new Input
{
Bathrooms = 1.0f,
Bedrooms = 1.0f,
TotalRooms = 3.0f,
FinishedSquareFeet = 653.0f,
UseCode = "Condominium",
LastSoldPrice = 0.0f
};
var prediction = predictor.Predict(input);
Console.WriteLine($"Predicted price: ${prediction.Price:n0}; Actual price: $665,000");
Console.WriteLine();
}
private static void Evaluate(PredictionModel <TaxiTrip, TaxiTripFarePrediction> model)
{
// <Snippet12>
var testData = new TextLoader(_testdatapath).CreateFrom <TaxiTrip>(useHeader: true, separator: ',');
// </Snippet12>
// <Snippet13>
var evaluator = new RegressionEvaluator();
RegressionMetrics metrics = evaluator.Evaluate(model, testData);
// </Snippet13>
// <Snippet14>
Console.WriteLine($"Rms = {metrics.Rms}");
// </Snippet14>
// <Snippet15>
Console.WriteLine($"RSquared = {metrics.RSquared}");
// </Snippet15>
}
/// <summary>
/// Loads the data and train.
/// </summary>
/// <param name="products">The products.</param>
/// <returns>an instance of <see cref="ITransformer"/>.</returns>
private ITransformer LoadDataAndTrain(IEnumerable <ProductEntry> products)
{
// Read the trained data using TextLoader by defining the schema for reading the product co-purchase data-set
IDataView productData = this.mlContext.Data.LoadFromEnumerable(data: products);
DataOperationsCatalog.TrainTestData trainTestData = this.mlContext.Data.TrainTestSplit(productData, testFraction: 0.2, seed: 1);
IDataView trainDataView = trainTestData.TrainSet;
IDataView testDataView = trainTestData.TestSet;
IDataView cachedData = this.mlContext.Data.Cache(trainDataView);
// Your data is already encoded so all you need to do is specify options for MatrixFactorizationTrainer with a few extra hyper parameters
// LossFunction, Alpha, Lambda and a few others like K and C as shown below and call the trainer.
MatrixFactorizationTrainer.Options options = new MatrixFactorizationTrainer.Options
{
MatrixColumnIndexColumnName =
nameof(ProductEntry.ProductId),
MatrixRowIndexColumnName =
nameof(ProductEntry.CoPurchaseProductId),
LabelColumnName = nameof(ProductEntry.Label),
LossFunction =
MatrixFactorizationTrainer.LossFunctionType
.SquareLossOneClass,
Alpha = 0.01,
Lambda = 0.025,
ApproximationRank = 128,
C = 0.00001
};
// Call the MatrixFactorization trainer by passing options.
MatrixFactorizationTrainer est = this.mlContext.Recommendation().Trainers
.MatrixFactorization(options: options);
// Train the model fitting to the DataSet
ITransformer trainedModel = est.Fit(input: cachedData);
IDataView predictions = trainedModel.Transform(testDataView);
RegressionMetrics metrics = this.mlContext.Regression.Evaluate(predictions);
this.log.Information($"The model evaluation metrics RootMeanSquaredError:{metrics.RootMeanSquaredError}, LossFunction:{metrics.LossFunction}, MeanAbsoluteError:{metrics.MeanAbsoluteError}, MeanSquaredError:{metrics.MeanSquaredError}");
return(trainedModel);
}
private static void Evaluate(PredictionModel <TaxiTrip, TaxiTripFarePrediction> model)
{
// <Snippet12>
var testData = new TextLoader <TaxiTrip>(_testdatapath, useHeader: true, separator: ",");
// </Snippet12>
// <Snippet13>
var evaluator = new RegressionEvaluator();
RegressionMetrics metrics = evaluator.Evaluate(model, testData);
// </Snippet13>
// <Snippet14>
// Rms should be around 2.795276
Console.WriteLine("Rms=" + metrics.Rms);
// </Snippet14>
// <Snippet15>
Console.WriteLine("RSquared = " + metrics.RSquared);
// </Snippet15>
}
static void Main(string[] args)
{
// Cria o contexto que trabalhará com aprendizado de máquina.
MLContext context = new MLContext();
// Lê o arquivo e o transforma em um dataset.
TrainTestData splitData = Sanitize(context);
ITransformer model = Train(context, splitData.TrainSet);
RegressionMetrics metrics = Evaluate(context, model, splitData.TestSet);
SaveModel(context, model, splitData.TrainSet.Schema);
PrintMetrics(metrics);
PredictPrice(context, model);
Console.ReadLine();
}
/// <summary>
/// Create, Train, Evaluate and Save a model.
/// Common data loading configuration.
/// </summary>
/// <param name="mlContext"></param>
/// <returns></returns>
private static ITransformer BuildTrainEvaluateAndSaveModel(MLContext mlContext)
{
SdcaRegressionTrainer trainer;
EstimatorChain <RegressionPredictionTransformer <LinearRegressionModelParameters> > trainingPipeline;
IDataView baseTrainingDataView =
mlContext.Data.LoadFromTextFile <AirTravel>(TrainDataPath, hasHeader: true, separatorChar: ',');
IDataView testDataView =
mlContext.Data.LoadFromTextFile <AirTravel>(TestDataPath, hasHeader: true, separatorChar: ',');
IDataView trainingDataView = GetTrainingDataView(mlContext, baseTrainingDataView);
var dataProcessPipeline = GetDataProcessPipeline(mlContext);
SetTrainingAlgorithm(mlContext, dataProcessPipeline, out trainer, out trainingPipeline);
var trainedModel = GetTrainedModel(trainingPipeline, trainingDataView);
RegressionMetrics metrics = Evaluate(mlContext, testDataView, trainedModel);
Common.ConsoleHelper.PrintRegressionMetrics(trainer.ToString(), metrics);
SaveModel(mlContext, trainingDataView, trainedModel);
return(trainedModel);
}
public async Task <IActionResult> GetWinningTeam(GetWinningTeamDTO dto)
{
Game teamAStats;
Game teamBStats;
if (dto.TeamAFeatures != null && dto.TeamBFeatures != null &&
dto.TeamAFeatures.Any() && dto.TeamBFeatures.Any())
{
teamAStats = GetGameStats(dto.TeamAId, dto.TeamAYear, dto.TeamAFeatures);
teamBStats = GetGameStats(dto.TeamBId, dto.TeamBYear, dto.TeamBFeatures);
}
else
{
teamAStats = await GetGameStats(dto.TeamAId, dto.TeamAYear, dto.Features);
teamBStats = await GetGameStats(dto.TeamBId, dto.TeamBYear, dto.Features);
}
ITransformer model = _gamePointsPredictionEngine.Train(dto.Features);
RegressionMetrics metrics = _gamePointsPredictionEngine.Evaluate(model);
var forecast = new ForecastResultDTO
{
Metrics = metrics,
TeamAStats = teamAStats.GetKeyValuePairs(),
TeamBStats = teamBStats.GetKeyValuePairs()
};
forecast.TeamAPoints = (int)_gamePointsPredictionEngine.PredictGamePoints(teamAStats, model).Points;
forecast.TeamBPoints = (int)_gamePointsPredictionEngine.PredictGamePoints(teamBStats, model).Points;
return(Ok(forecast));
}
private static IEnumerable <TimeSeriesAnalysis> Analyze(IEnumerable <TimeSeries> timeSeriesList)
{
const int horizon = 100;
foreach (TimeSeries timeSeries in timeSeriesList)
{
Observation[] observations = GapFiller.FillGaps(timeSeries.Observations, timeSeries.Interval).ToArray();
Observation[] historical = observations.Take(observations.Length - horizon).ToArray();
Observation[] actual = observations.Skip(observations.Length - horizon).ToArray();
var forecasts = new List <ForecastDetails>();
Observation[] linearRegressionForecast = LinearRegressionForecaster
.Forecast(historical, horizon, timeSeries.Interval);
RegressionMetrics linearRegressionMetrics = ForecastScorer.Evaluate(actual, linearRegressionForecast);
forecasts.Add(new ForecastDetails("Linear Regression", linearRegressionForecast, linearRegressionMetrics));
Observation[] ssaForecast = SsaForecaster.Forecast(historical, horizon, timeSeries.Interval);
RegressionMetrics ssaMetrics = ForecastScorer.Evaluate(actual, ssaForecast);
forecasts.Add(new ForecastDetails("SSA", ssaForecast, ssaMetrics));
var analysis = new TimeSeriesAnalysis(timeSeries, historical, actual, forecasts);
yield return(analysis);
}
}
