public FullPrediction[] Predict(GitHubIssue issue)
{
var prediction = _predEngine.Predict(issue);
var fullPredictions = GetBestThreePredictions(prediction);
return(fullPredictions);
}
public static void BuildAndTrainModel(string DataSetLocation, string ModelPath)
{
// Create MLContext to be shared across the model creation workflow objects
// Set a random seed for repeatable/deterministic results across multiple trainings.
var mlContext = new MLContext(seed: 0);
// STEP 1: Common data loading configuration
DataLoader dataLoader = new DataLoader(mlContext);
var trainingDataView = dataLoader.GetDataView(DataSetLocation);
// STEP 2: Common data process configuration with pipeline data transformations
var dataProcessor = new DataProcessor(mlContext);
var dataProcessPipeline = dataProcessor.DataProcessPipeline;
// (OPTIONAL) Peek data (such as 2 records) in training DataView after applying the ProcessPipeline's transformations into "Features"
Common.ConsoleHelper.PeekDataViewInConsole <GitHubIssue>(mlContext, trainingDataView, dataProcessPipeline, 2);
//Common.ConsoleHelper.PeekVectorColumnDataInConsole(mlContext, "Features", trainingDataView, dataProcessPipeline, 2);
// STEP 3: Set the selected training algorithm into the modelBuilder
var modelBuilder = new Common.ModelBuilder <GitHubIssue, GitHubIssuePrediction>(mlContext, dataProcessPipeline);
var trainer = mlContext.MulticlassClassification.Trainers.StochasticDualCoordinateAscent("Label", "Features");
modelBuilder.AddTrainer(trainer);
modelBuilder.AddEstimator(new KeyToValueEstimator(mlContext, "PredictedLabel"));
// STEP 4: Cross-Validate with single dataset (since we don't have two datasets, one for training and for evaluate)
// in order to evaluate and get the model's accuracy metrics
Console.WriteLine("=============== Cross-validating to get model's accuracy metrics ===============");
var crossValResults = modelBuilder.CrossValidateAndEvaluateMulticlassClassificationModel(trainingDataView, 6, "Label");
ConsoleHelper.PrintMulticlassClassificationFoldsAverageMetrics("SdcaMultiClassTrainer", crossValResults);
// STEP 5: Train the model fitting to the DataSet
Console.WriteLine("=============== Training the model ===============");
modelBuilder.Train(trainingDataView);
// STEP 6: Save/persist the trained model to a .ZIP file
Console.WriteLine("=============== Saving the model to a file ===============");
modelBuilder.SaveModelAsFile(ModelPath);
// (OPTIONAL) Try/test a single prediction by loding the model from the file, first.
GitHubIssue issue = new GitHubIssue()
{
ID = "Any-ID", Title = "Entity Framework crashes", Description = "When connecting to the database, EF is crashing"
};
var modelScorer = new ModelScorer <GitHubIssue, GitHubIssuePrediction>(mlContext);
modelScorer.LoadModelFromZipFile(ModelPath);
var prediction = modelScorer.PredictSingle(issue);
Console.WriteLine($"=============== Single Prediction - Result: {prediction.Area} ===============");
//
Common.ConsoleHelper.ConsoleWriteHeader("Training process finalized");
}
public static async Task <string> PredictAsync(GitHubIssue issue)
{
if (_model == null)
{
_model = await PredictionModel.ReadAsync <GitHubIssue, GitHubIssuePrediction>(ModelPath);
}
var prediction = _model.Predict(issue);
return(prediction.Area);
}
public void TestPredictionForSingleIssue()
{
GitHubIssue singleIssue = new GitHubIssue()
{
ID = "Any-ID", Title = "Entity Framework crashes", Description = "When connecting to the database, EF is crashing"
};
//Predict label for single hard-coded issue
var prediction = _modelScorer.PredictSingle(singleIssue);
Console.WriteLine($"=============== Single Prediction - Result: {prediction.Area} ===============");
}
private FullPrediction[] PredictLabels(Octokit.Issue issue)
{
var corefxIssue = new GitHubIssue
{
ID = issue.Number.ToString(),
Title = issue.Title,
Description = issue.Body
};
_fullPredictions = Predict(corefxIssue);
return(_fullPredictions);
}
private string PredictLabel(Issue issue)
{
var corefxIssue = new GitHubIssue
{
ID = issue.Number.ToString(),
Title = issue.Title,
Description = issue.Body
};
var predictedLabel = Predictor.Predict(corefxIssue);
return predictedLabel;
}
private async Task <string> PredictLabel(Issue issue)
{
var corefxIssue = new GitHubIssue
{
ID = issue.Number.ToString(),
Title = issue.Title,
Description = issue.Body
};
var predictedLabel = await Predictor.PredictAsync(corefxIssue);
return(predictedLabel);
}
public static string Predict(GitHubIssue issue)
{
using (var env = new LocalEnvironment())
{
ITransformer loadedModel;
using (var stream = new FileStream(ModelPath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
loadedModel = TransformerChain.LoadFrom(env, stream);
}
// Create prediction engine and make prediction.
var engine = loadedModel.MakePredictionFunction <GitHubIssue, GitHubIssuePrediction>(env);
var prediction = engine.Predict(issue);
return(prediction.Area);
}
}
public void TestPredictionForSingleIssue()
{
GitHubIssue singleIssue = new GitHubIssue()
{
ID = "Any-ID",
Title = "Crash in SqlConnection when using TransactionScope",
Description = "I'm using SqlClient in netcoreapp2.0. Sqlclient.Close() crashes in Linux but works on Windows"
};
//Predict labels and scores for single hard-coded issue
var prediction = _predEngine.Predict(singleIssue);
_fullPredictions = GetBestThreePredictions(prediction);
Console.WriteLine("1st Label: " + _fullPredictions[0].PredictedLabel + " with score: " + _fullPredictions[0].Score);
Console.WriteLine("2nd Label: " + _fullPredictions[1].PredictedLabel + " with score: " + _fullPredictions[1].Score);
Console.WriteLine("3rd Label: " + _fullPredictions[2].PredictedLabel + " with score: " + _fullPredictions[2].Score);
Console.WriteLine($"=============== Single Prediction - Result: {prediction.Area} ===============");
}
public static void BuildAndTrainModel(string DataSetLocation, string ModelPath, MyTrainerStrategy selectedStrategy)
{
// Create MLContext to be shared across the model creation workflow objects
// Set a random seed for repeatable/deterministic results across multiple trainings.
var mlContext = new MLContext(seed: 0);
// STEP 1: Common data loading configuration
var trainingDataView = mlContext.Data.ReadFromTextFile <GitHubIssue>(DataSetLocation, hasHeader: true, separatorChar: '\t');
// STEP 2: Common data process configuration with pipeline data transformations
var dataProcessPipeline = mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: DefaultColumnNames.Label, inputColumnName: nameof(GitHubIssue.Area))
.Append(mlContext.Transforms.Text.FeaturizeText(outputColumnName: "TitleFeaturized", inputColumnName: nameof(GitHubIssue.Title)))
.Append(mlContext.Transforms.Text.FeaturizeText(outputColumnName: "DescriptionFeaturized", inputColumnName: nameof(GitHubIssue.Description)))
.Append(mlContext.Transforms.Concatenate(outputColumnName: DefaultColumnNames.Features, "TitleFeaturized", "DescriptionFeaturized"))
//Sample Caching the DataView so estimators iterating over the data multiple times, instead of always reading from file, using the cache might get better performance
.AppendCacheCheckpoint(mlContext); //In this sample, only when using OVA (Not SDCA) the cache improves the training time, since OVA works multiple times/iterations over the same data
// (OPTIONAL) Peek data (such as 2 records) in training DataView after applying the ProcessPipeline's transformations into "Features"
Common.ConsoleHelper.PeekDataViewInConsole <GitHubIssue>(mlContext, trainingDataView, dataProcessPipeline, 2);
//Common.ConsoleHelper.PeekVectorColumnDataInConsole(mlContext, "Features", trainingDataView, dataProcessPipeline, 2);
// STEP 3: Create the selected training algorithm/trainer
IEstimator <ITransformer> trainer = null;
switch (selectedStrategy)
{
case MyTrainerStrategy.SdcaMultiClassTrainer:
trainer = mlContext.MulticlassClassification.Trainers.StochasticDualCoordinateAscent(DefaultColumnNames.Label,
DefaultColumnNames.Features);
break;
case MyTrainerStrategy.OVAAveragedPerceptronTrainer:
{
// Create a binary classification trainer.
var averagedPerceptronBinaryTrainer = mlContext.BinaryClassification.Trainers.AveragedPerceptron(DefaultColumnNames.Label,
DefaultColumnNames.Features,
numIterations: 10);
// Compose an OVA (One-Versus-All) trainer with the BinaryTrainer.
// In this strategy, a binary classification algorithm is used to train one classifier for each class, "
// which distinguishes that class from all other classes. Prediction is then performed by running these binary classifiers, "
// and choosing the prediction with the highest confidence score.
trainer = mlContext.MulticlassClassification.Trainers.OneVersusAll(averagedPerceptronBinaryTrainer);
break;
}
default:
break;
}
//Set the trainer/algorithm and map label to value (original readable state)
var trainingPipeline = dataProcessPipeline.Append(trainer)
.Append(mlContext.Transforms.Conversion.MapKeyToValue(DefaultColumnNames.PredictedLabel));
// STEP 4: Cross-Validate with single dataset (since we don't have two datasets, one for training and for evaluate)
// in order to evaluate and get the model's accuracy metrics
Console.WriteLine("=============== Cross-validating to get model's accuracy metrics ===============");
//Measure cross-validation time
var watchCrossValTime = System.Diagnostics.Stopwatch.StartNew();
var crossValidationResults = mlContext.MulticlassClassification.CrossValidate(data: trainingDataView, estimator: trainingPipeline, numFolds: 6, labelColumn: DefaultColumnNames.Label);
//Stop measuring time
watchCrossValTime.Stop();
long elapsedMs = watchCrossValTime.ElapsedMilliseconds;
Console.WriteLine($"Time Cross-Validating: {elapsedMs} miliSecs");
//(CDLTLL-Pending-TODO)
//
ConsoleHelper.PrintMulticlassClassificationFoldsAverageMetrics(trainer.ToString(), crossValidationResults);
// STEP 5: Train the model fitting to the DataSet
Console.WriteLine("=============== Training the model ===============");
//Measure training time
var watch = System.Diagnostics.Stopwatch.StartNew();
var trainedModel = trainingPipeline.Fit(trainingDataView);
//Stop measuring time
watch.Stop();
long elapsedCrossValMs = watch.ElapsedMilliseconds;
Console.WriteLine($"Time Training the model: {elapsedCrossValMs} miliSecs");
// (OPTIONAL) Try/test a single prediction with the "just-trained model" (Before saving the model)
GitHubIssue issue = new GitHubIssue()
{
ID = "Any-ID", Title = "WebSockets communication is slow in my machine", Description = "The WebSockets communication used under the covers by SignalR looks like is going slow in my development machine.."
};
// Create prediction engine related to the loaded trained model
var predEngine = trainedModel.CreatePredictionEngine <GitHubIssue, GitHubIssuePrediction>(mlContext);
//Score
var prediction = predEngine.Predict(issue);
Console.WriteLine($"=============== Single Prediction just-trained-model - Result: {prediction.Area} ===============");
//
// STEP 6: Save/persist the trained model to a .ZIP file
Console.WriteLine("=============== Saving the model to a file ===============");
using (var fs = new FileStream(ModelPath, FileMode.Create, FileAccess.Write, FileShare.Write))
mlContext.Model.Save(trainedModel, fs);
Common.ConsoleHelper.ConsoleWriteHeader("Training process finalized");
}
public static void BuildAndTrainModel(string DataSetLocation, string ModelPath, MyTrainerStrategy selectedStrategy)
{
// Create MLContext to be shared across the model creation workflow objects
// Set a random seed for repeatable/deterministic results across multiple trainings.
var mlContext = new MLContext(seed: 0);
// STEP 1: Common data loading configuration
TextLoader textLoader = mlContext.Data.TextReader(new TextLoader.Arguments()
{
Separator = "tab",
HasHeader = true,
Column = new[]
{
new TextLoader.Column("ID", DataKind.Text, 0),
new TextLoader.Column("Area", DataKind.Text, 1),
new TextLoader.Column("Title", DataKind.Text, 2),
new TextLoader.Column("Description", DataKind.Text, 3),
}
});
var trainingDataView = textLoader.Read(DataSetLocation);
// STEP 2: Common data process configuration with pipeline data transformations
var dataProcessPipeline = mlContext.Transforms.Categorical.MapValueToKey("Area", "Label")
.Append(mlContext.Transforms.Text.FeaturizeText("Title", "TitleFeaturized"))
.Append(mlContext.Transforms.Text.FeaturizeText("Description", "DescriptionFeaturized"))
.Append(mlContext.Transforms.Concatenate("Features", "TitleFeaturized", "DescriptionFeaturized"));
// (OPTIONAL) Peek data (such as 2 records) in training DataView after applying the ProcessPipeline's transformations into "Features"
Common.ConsoleHelper.PeekDataViewInConsole <GitHubIssue>(mlContext, trainingDataView, dataProcessPipeline, 2);
//Common.ConsoleHelper.PeekVectorColumnDataInConsole(mlContext, "Features", trainingDataView, dataProcessPipeline, 2);
// STEP 3: Create the selected training algorithm/trainer
IEstimator <ITransformer> trainer = null;
switch (selectedStrategy)
{
case MyTrainerStrategy.SdcaMultiClassTrainer:
trainer = mlContext.MulticlassClassification.Trainers.StochasticDualCoordinateAscent(DefaultColumnNames.Label,
DefaultColumnNames.Features);
break;
case MyTrainerStrategy.OVAAveragedPerceptronTrainer:
{
// Create a binary classification trainer.
var averagedPerceptronBinaryTrainer = mlContext.BinaryClassification.Trainers.AveragedPerceptron(DefaultColumnNames.Label,
DefaultColumnNames.Features,
numIterations: 10);
// Compose an OVA (One-Versus-All) trainer with the BinaryTrainer.
// In this strategy, a binary classification algorithm is used to train one classifier for each class, "
// which distinguishes that class from all other classes. Prediction is then performed by running these binary classifiers, "
// and choosing the prediction with the highest confidence score.
trainer = new Ova(mlContext, averagedPerceptronBinaryTrainer);
break;
}
default:
break;
}
//Set the trainer/algorithm and map label to value (original readable state)
var trainingPipeline = dataProcessPipeline.Append(trainer)
.Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));
// STEP 4: Cross-Validate with single dataset (since we don't have two datasets, one for training and for evaluate)
// in order to evaluate and get the model's accuracy metrics
Console.WriteLine("=============== Cross-validating to get model's accuracy metrics ===============");
var crossValidationResults = mlContext.MulticlassClassification.CrossValidate(trainingDataView, trainingPipeline, numFolds: 6, labelColumn: "Label");
ConsoleHelper.PrintMulticlassClassificationFoldsAverageMetrics(trainer.ToString(), crossValidationResults);
// STEP 5: Train the model fitting to the DataSet
Console.WriteLine("=============== Training the model ===============");
var trainedModel = trainingPipeline.Fit(trainingDataView);
// (OPTIONAL) Try/test a single prediction with the "just-trained model" (Before saving the model)
GitHubIssue issue = new GitHubIssue()
{
ID = "Any-ID", Title = "WebSockets communication is slow in my machine", Description = "The WebSockets communication used under the covers by SignalR looks like is going slow in my development machine.."
};
// Create prediction engine related to the loaded trained model
var predFunction = trainedModel.MakePredictionFunction <GitHubIssue, GitHubIssuePrediction>(mlContext);
//Score
var prediction = predFunction.Predict(issue);
Console.WriteLine($"=============== Single Prediction just-trained-model - Result: {prediction.Area} ===============");
//
// STEP 6: Save/persist the trained model to a .ZIP file
Console.WriteLine("=============== Saving the model to a file ===============");
using (var fs = new FileStream(ModelPath, FileMode.Create, FileAccess.Write, FileShare.Write))
mlContext.Model.Save(trainedModel, fs);
Common.ConsoleHelper.ConsoleWriteHeader("Training process finalized");
}
public static void BuildAndTrainModel(string DataSetLocation, string ModelPath, MyTrainerStrategy selectedStrategy)
{
// Create MLContext to be shared across the model creation workflow objects
// Set a random seed for repeatable/deterministic results across multiple trainings.
var mlContext = new MLContext(seed: 1);
// STEP 1: Common data loading configuration
var trainingDataView = mlContext.Data.LoadFromTextFile<GitHubIssue>(DataSetLocation, hasHeader: true, separatorChar:'\t', allowSparse: false);
// STEP 2: Common data process configuration with pipeline data transformations
var dataProcessPipeline = mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "Label",inputColumnName:nameof(GitHubIssue.Area))
.Append(mlContext.Transforms.Text.FeaturizeText(outputColumnName: "TitleFeaturized",inputColumnName:nameof(GitHubIssue.Title)))
.Append(mlContext.Transforms.Text.FeaturizeText(outputColumnName: "DescriptionFeaturized", inputColumnName: nameof(GitHubIssue.Description)))
.Append(mlContext.Transforms.Concatenate(outputColumnName:"Features", "TitleFeaturized", "DescriptionFeaturized"))
.AppendCacheCheckpoint(mlContext);
// Use in-memory cache for small/medium datasets to lower training time.
// Do NOT use it (remove .AppendCacheCheckpoint()) when handling very large datasets.
// (OPTIONAL) Peek data (such as 2 records) in training DataView after applying the ProcessPipeline's transformations into "Features"
Common.ConsoleHelper.PeekDataViewInConsole(mlContext, trainingDataView, dataProcessPipeline, 2);
// STEP 3: Create the selected training algorithm/trainer
IEstimator<ITransformer> trainer = null;
switch(selectedStrategy)
{
case MyTrainerStrategy.SdcaMultiClassTrainer:
trainer = mlContext.MulticlassClassification.Trainers.SdcaMaximumEntropy("Label", "Features");
break;
case MyTrainerStrategy.OVAAveragedPerceptronTrainer:
{
// Create a binary classification trainer.
var averagedPerceptronBinaryTrainer = mlContext.BinaryClassification.Trainers.AveragedPerceptron("Label", "Features",numberOfIterations: 10);
// Compose an OVA (One-Versus-All) trainer with the BinaryTrainer.
// In this strategy, a binary classification algorithm is used to train one classifier for each class, "
// which distinguishes that class from all other classes. Prediction is then performed by running these binary classifiers, "
// and choosing the prediction with the highest confidence score.
trainer = mlContext.MulticlassClassification.Trainers.OneVersusAll(averagedPerceptronBinaryTrainer);
break;
}
default:
break;
}
//Set the trainer/algorithm and map label to value (original readable state)
var trainingPipeline = dataProcessPipeline.Append(trainer)
.Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));
// STEP 4: Cross-Validate with single dataset (since we don't have two datasets, one for training and for evaluate)
// in order to evaluate and get the model's accuracy metrics
Console.WriteLine("=============== Cross-validating to get model's accuracy metrics ===============");
var crossValidationResults= mlContext.MulticlassClassification.CrossValidate(data:trainingDataView, estimator:trainingPipeline, numberOfFolds: 6, labelColumnName:"Label");
ConsoleHelper.PrintMulticlassClassificationFoldsAverageMetrics(trainer.ToString(), crossValidationResults);
// STEP 5: Train the model fitting to the DataSet
Console.WriteLine("=============== Training the model ===============");
var trainedModel = trainingPipeline.Fit(trainingDataView);
// (OPTIONAL) Try/test a single prediction with the "just-trained model" (Before saving the model)
GitHubIssue issue = new GitHubIssue() { ID = "Any-ID", Title = "WebSockets communication is slow in my machine", Description = "The WebSockets communication used under the covers by SignalR looks like is going slow in my development machine.." };
// Create prediction engine related to the loaded trained model
var predEngine = mlContext.Model.CreatePredictionEngine<GitHubIssue, GitHubIssuePrediction>(trainedModel);
//Score
var prediction = predEngine.Predict(issue);
Console.WriteLine($"=============== Single Prediction just-trained-model - Result: {prediction.Area} ===============");
//
// STEP 6: Save/persist the trained model to a .ZIP file
Console.WriteLine("=============== Saving the model to a file ===============");
mlContext.Model.Save(trainedModel, trainingDataView.Schema, ModelPath);
Common.ConsoleHelper.ConsoleWriteHeader("Training process finalized");
}
public string Predict(GitHubIssue issue)
{
var prediction = _modelScorer.PredictSingle(issue);
return(prediction.Area);
}
public static void BuildAndTrainModel(string DataSetLocation, string ModelPath, MyTrainerStrategy selectedStrategy)
{
// Create MLContext to be shared across the model creation workflow objects
// Set a random seed for repeatable/deterministic results across multiple trainings.
var mlContext = new MLContext(seed: 0);
// STEP 1: Common data loading configuration
var textLoader = GitHubLabelerTextLoaderFactory.CreateTextLoader(mlContext);
var trainingDataView = textLoader.Read(DataSetLocation);
// STEP 2: Common data process configuration with pipeline data transformations
var dataProcessPipeline = GitHubLabelerDataProcessPipelineFactory.CreateDataProcessPipeline(mlContext);
// (OPTIONAL) Peek data (such as 2 records) in training DataView after applying the ProcessPipeline's transformations into "Features"
Common.ConsoleHelper.PeekDataViewInConsole <GitHubIssue>(mlContext, trainingDataView, dataProcessPipeline, 2);
//Common.ConsoleHelper.PeekVectorColumnDataInConsole(mlContext, "Features", trainingDataView, dataProcessPipeline, 2);
// STEP 3: Create the selected training algorithm/trainer
IEstimator <ITransformer> trainer = null;
switch (selectedStrategy)
{
case MyTrainerStrategy.SdcaMultiClassTrainer:
trainer = mlContext.MulticlassClassification.Trainers.StochasticDualCoordinateAscent(DefaultColumnNames.Label,
DefaultColumnNames.Features);
break;
case MyTrainerStrategy.OVAAveragedPerceptronTrainer:
{
// Create a binary classification trainer.
var averagedPerceptronBinaryTrainer = mlContext.BinaryClassification.Trainers.AveragedPerceptron(DefaultColumnNames.Label,
DefaultColumnNames.Features,
numIterations: 10);
// Compose an OVA (One-Versus-All) trainer with the BinaryTrainer.
// In this strategy, a binary classification algorithm is used to train one classifier for each class, "
// which distinguishes that class from all other classes. Prediction is then performed by running these binary classifiers, "
// and choosing the prediction with the highest confidence score.
trainer = new Ova(mlContext, averagedPerceptronBinaryTrainer);
break;
}
default:
break;
}
//Set the trainer/algorithm
var modelBuilder = new Common.ModelBuilder <GitHubIssue, GitHubIssuePrediction>(mlContext, dataProcessPipeline);
modelBuilder.AddTrainer(trainer);
modelBuilder.AddEstimator(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabel"));
// STEP 4: Cross-Validate with single dataset (since we don't have two datasets, one for training and for evaluate)
// in order to evaluate and get the model's accuracy metrics
Console.WriteLine("=============== Cross-validating to get model's accuracy metrics ===============");
var crossValResults = modelBuilder.CrossValidateAndEvaluateMulticlassClassificationModel(trainingDataView, 6, "Label");
ConsoleHelper.PrintMulticlassClassificationFoldsAverageMetrics(trainer.ToString(), crossValResults);
// STEP 5: Train the model fitting to the DataSet
Console.WriteLine("=============== Training the model ===============");
modelBuilder.Train(trainingDataView);
// (OPTIONAL) Try/test a single prediction with the "just-trained model" (Before saving the model)
GitHubIssue issue = new GitHubIssue()
{
ID = "Any-ID", Title = "WebSockets communication is slow in my machine", Description = "The WebSockets communication used under the covers by SignalR looks like is going slow in my development machine.."
};
var modelScorer = new ModelScorer <GitHubIssue, GitHubIssuePrediction>(mlContext, modelBuilder.TrainedModel);
var prediction = modelScorer.PredictSingle(issue);
Console.WriteLine($"=============== Single Prediction just-trained-model - Result: {prediction.Area} ===============");
//
// STEP 6: Save/persist the trained model to a .ZIP file
Console.WriteLine("=============== Saving the model to a file ===============");
modelBuilder.SaveModelAsFile(ModelPath);
Common.ConsoleHelper.ConsoleWriteHeader("Training process finalized");
}
public string Predict(GitHubIssue issue)
{
var prediction = _predEngine.Predict(issue);
return(prediction.Area);
}