public Labeler(string modelPath, string repoOwner = "", string repoName = "", string accessToken = "")
{
_modelPath = modelPath;
_repoOwner = repoOwner;
_repoName = repoName;
_mlContext = new MLContext(seed: 1);
//Load model from file
using (var stream = new FileStream(_modelPath, System.IO.FileMode.Open, FileAccess.Read, FileShare.Read))
{
_trainedModel = _mlContext.Model.Load(stream);
}
// Create prediction engine related to the loaded trained model
_predFunction = _trainedModel.MakePredictionFunction <GitHubIssue, GitHubIssuePrediction>(_mlContext);
//Configure Client to access a GitHub repo
if (accessToken != string.Empty)
{
var productInformation = new ProductHeaderValue("MLGitHubLabeler");
_client = new GitHubClient(productInformation)
{
Credentials = new Credentials(accessToken)
};
}
}
public void SetupIrisPipeline()
{
_irisExample = new IrisData()
{
SepalLength = 3.3f,
SepalWidth = 1.6f,
PetalLength = 0.2f,
PetalWidth = 5.1f,
};
string _irisDataPath = Program.GetInvariantCultureDataPath("iris.txt");
var env = new MLContext(seed: 1, conc: 1);
var reader = new TextLoader(env,
columns: new[]
{
new TextLoader.Column("Label", DataKind.R4, 0),
new TextLoader.Column("SepalLength", DataKind.R4, 1),
new TextLoader.Column("SepalWidth", DataKind.R4, 2),
new TextLoader.Column("PetalLength", DataKind.R4, 3),
new TextLoader.Column("PetalWidth", DataKind.R4, 4),
},
hasHeader: true
);
IDataView data = reader.Read(_irisDataPath);
var pipeline = new ColumnConcatenatingEstimator(env, "Features", new[] { "SepalLength", "SepalWidth", "PetalLength", "PetalWidth" })
.Append(new SdcaMultiClassTrainer(env, "Label", "Features", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; }));
var model = pipeline.Fit(data);
_irisModel = model.MakePredictionFunction <IrisData, IrisPrediction>(env);
}
// Controller
public HomeController(ISeederRepository repository,
PredictionFunction <StdRoomRateData, RoomRatePrediction> StdRoomRatePredFunction,
PredictionFunction <SprRoomRateData, RoomRatePrediction> SprRoomRatePredFunction,
PredictionFunction <FamRoomRateData, RoomRatePrediction> FamRoomRatePredFunction,
PredictionFunction <SuiteRoomRateData, RoomRatePrediction> SuiteRoomRatePredFunction,
PredictionFunction <DlxRoomRateData, RoomRatePrediction> DlxRoomRatePredFunction,
PredictionFunction <StdOccupancyData, OccupancyPrediction> StdOccupancyPredFunction,
PredictionFunction <SprOccupancyData, OccupancyPrediction> SprOccupancyPredFunction,
PredictionFunction <FamOccupancyData, OccupancyPrediction> FamOccupancyPredFunction,
PredictionFunction <SuiteOccupancyData, OccupancyPrediction> SuiteOccupancyPredFunction,
PredictionFunction <DlxOccupancyData, OccupancyPrediction> DlxOccupancyPredFunction)
{
this.repository = repository;
this.StdRoomRatePredFunction = StdRoomRatePredFunction;
this.SprRoomRatePredFunction = SprRoomRatePredFunction;
this.FamRoomRatePredFunction = FamRoomRatePredFunction;
this.SuiteRoomRatePredFunction = SuiteRoomRatePredFunction;
this.DlxRoomRatePredFunction = DlxRoomRatePredFunction;
this.StdOccupancyPredFunction = StdOccupancyPredFunction;
this.SprOccupancyPredFunction = SprOccupancyPredFunction;
this.FamOccupancyPredFunction = FamOccupancyPredFunction;
this.SuiteOccupancyPredFunction = SuiteOccupancyPredFunction;
this.DlxOccupancyPredFunction = DlxOccupancyPredFunction;
}
protected void EvaluateModel(string testLocation, PredictionFunction <ImageNetData, ImageNetPrediction> model)
{
ConsoleWriteHeader("Metrics for Image Classification");
var evaluator = new MultiClassClassifierEvaluator(env, new MultiClassClassifierEvaluator.Arguments());
var data = TextLoader.ReadFile(env,
new TextLoader.Arguments
{
Separator = "tab",
HasHeader = false,
Column = new []
{
new TextLoader.Column("ImagePath", DataKind.Text, 0),
new TextLoader.Column("Label", DataKind.Text, 1)
}
},
new MultiFileSource(testLocation));
var evalRoles = new RoleMappedData(data, label: "Label", feature: "ImagePath");
var metrics = evaluator.Evaluate(evalRoles);
//var logLoss = metrics[MultiClassClassifierEvaluator.LogLoss];
foreach (var item in metrics)
{
Console.WriteLine($"{item.Key}: {item.Value}");
}
}
public void SetupBreastCancerPipeline()
{
_breastCancerExample = new BreastCancerData()
{
Features = new[] { 5f, 1f, 1f, 1f, 2f, 1f, 3f, 1f, 1f }
};
string _breastCancerDataPath = Program.GetInvariantCultureDataPath("breast-cancer.txt");
using (var env = new ConsoleEnvironment(seed: 1, conc: 1, verbose: false, sensitivity: MessageSensitivity.None, outWriter: EmptyWriter.Instance))
{
var reader = new TextLoader(env,
new TextLoader.Arguments()
{
Separator = "\t",
HasHeader = false,
Column = new[]
{
new TextLoader.Column("Label", DataKind.BL, 0),
new TextLoader.Column("Features", DataKind.R4, new[] { new TextLoader.Range(1, 9) })
}
});
IDataView data = reader.Read(_breastCancerDataPath);
var pipeline = new LinearClassificationTrainer(env, "Features", "Label", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; });
var model = pipeline.Fit(data);
_breastCancerModel = model.MakePredictionFunction <BreastCancerData, BreastCancerPrediction>(env);
}
}
public void SetupSentimentPipeline()
{
_sentimentExample = new SentimentData()
{
SentimentText = "Not a big fan of this."
};
string _sentimentDataPath = Program.GetInvariantCultureDataPath("wikipedia-detox-250-line-data.tsv");
using (var env = new ConsoleEnvironment(seed: 1, conc: 1, verbose: false, sensitivity: MessageSensitivity.None, outWriter: EmptyWriter.Instance))
{
var reader = new TextLoader(env,
new TextLoader.Arguments()
{
Separator = "\t",
HasHeader = true,
Column = new[]
{
new TextLoader.Column("Label", DataKind.BL, 0),
new TextLoader.Column("SentimentText", DataKind.Text, 1)
}
});
IDataView data = reader.Read(_sentimentDataPath);
var pipeline = new TextTransform(env, "SentimentText", "Features")
.Append(new LinearClassificationTrainer(env, "Features", "Label", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; }));
var model = pipeline.Fit(data);
_sentimentModel = model.MakePredictionFunction <SentimentData, SentimentPrediction>(env);
}
}
private static void EvaluateModel(PredictionFunction <TrafficObservation, AlertPrediction> predictor)
{
Console.WriteLine("Predicting the Future!");
// Can you find a data set that would trigger the prediction to be true?
var predictionResult = predictor.Predict(new TrafficObservation()
{
AvgTotalBytes = 0,
AvgTotalPackets = 0,
AvgAveragebps = 0,
AvgOutPercentUtil = 0,
AvgInPercentUtil = 0,
AvgPercentUtil = 0,
MinTotalBytes = 0,
MinTotalPackets = 0,
MinAveragebps = 0,
MinOutPercentUtil = 0,
MinInPercentUtil = 0,
MinPercentUtil = 0,
MaxTotalBytes = 0,
MaxTotalPackets = 0,
MaxAveragebps = 0,
MaxOutPercentUtil = 0,
MaxInPercentUtil = 0,
MaxPercentUtil = 0
});
predictionResult.PrintToConsole();
}
public void SetupSentimentPipeline()
{
_sentimentExample = new SentimentData()
{
SentimentText = "Not a big fan of this."
};
string _sentimentDataPath = Program.GetInvariantCultureDataPath("wikipedia-detox-250-line-data.tsv");
var env = new MLContext(seed: 1, conc: 1);
var reader = new TextLoader(env,
new TextLoader.Arguments()
{
Separator = "\t",
HasHeader = true,
Column = new[]
{
new TextLoader.Column("Label", DataKind.BL, 0),
new TextLoader.Column("SentimentText", DataKind.Text, 1)
}
});
IDataView data = reader.Read(_sentimentDataPath);
var pipeline = new TextFeaturizingEstimator(env, "SentimentText", "Features")
.Append(new SdcaBinaryTrainer(env, "Label", "Features", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; }));
var model = pipeline.Fit(data);
_sentimentModel = model.MakePredictionFunction <SentimentData, SentimentPrediction>(env);
}
public void SetupBreastCancerPipeline()
{
_breastCancerExample = new BreastCancerData()
{
Features = new[] { 5f, 1f, 1f, 1f, 2f, 1f, 3f, 1f, 1f }
};
string _breastCancerDataPath = Program.GetInvariantCultureDataPath("breast-cancer.txt");
var env = new MLContext(seed: 1, conc: 1);
var reader = new TextLoader(env,
new TextLoader.Arguments()
{
Separator = "\t",
HasHeader = false,
Column = new[]
{
new TextLoader.Column("Label", DataKind.BL, 0),
new TextLoader.Column("Features", DataKind.R4, new[] { new TextLoader.Range(1, 9) })
}
});
IDataView data = reader.Read(_breastCancerDataPath);
var pipeline = new SdcaBinaryTrainer(env, "Label", "Features", advancedSettings: (s) => { s.NumThreads = 1; s.ConvergenceTolerance = 1e-2f; });
var model = pipeline.Fit(data);
_breastCancerModel = model.MakePredictionFunction <BreastCancerData, BreastCancerPrediction>(env);
}
public static void ClassifyMessage(PredictionFunction <SpamInput, SpamPrediction> predictor, string message)
{
var input = new SpamInput {
Message = message
};
var prediction = predictor.Predict(input);
Console.WriteLine("The message '{0}' is {1}", input.Message, prediction.isSpam ? "spam" : "not spam");
}
public ProductDemandForecastController(IOptionsSnapshot <AppSettings> appSettings,
PredictionFunction <ProductData, ProductUnitPrediction> productSalesPredFunction
)
{
this.appSettings = appSettings.Value;
// Get injected Product Sales Prediction function
this.productSalesPredFunction = productSalesPredFunction;
}
public ImageScoringService(string contentRoot, string rootImagesFolder)
{
_contentRoot = contentRoot;
_mlContext = new MLContext();
_modelLocation = Path.Combine(_contentRoot, "model", "model.pb");
_labels = ModelHelpers.ReadLabels(Path.Combine(_contentRoot, "model", "labels.txt"));
_imagesFolder = rootImagesFolder;
_model = null;
}
private static PredictionFunction <SpamInput, SpamPrediction> GetPredictor()
{
if (_predictor == null)
{
// Set up the MLContext, which is a catalog of components in ML.NET.
var mlContext = new MLContext();
// Create the reader and define which columns from the file should be read.
var reader = new TextLoader(mlContext, new TextLoader.Arguments()
{
Separator = "tab",
HasHeader = true,
Column = new[]
{
new TextLoader.Column("Label", DataKind.Text, 0),
new TextLoader.Column("Message", DataKind.Text, 1)
}
});
var data = reader.Read(new MultiFileSource(TrainDataPath));
// Create the estimator which converts the text label to boolean, featurizes the text, and adds a linear trainer.
var estimator = mlContext.Transforms.CustomMapping <MyInput, MyOutput>(MyLambda.MyAction, "MyLambda")
.Append(mlContext.Transforms.Text.FeaturizeText("Message", "Features"))
.Append(mlContext.BinaryClassification.Trainers.StochasticDualCoordinateAscent());
// Evaluate the model using cross-validation.
// Cross-validation splits our dataset into 'folds', trains a model on some folds and
// evaluates it on the remaining fold. We are using 5 folds so we get back 5 sets of scores.
// Let's compute the average AUC, which should be between 0.5 and 1 (higher is better).
var cvResults = mlContext.BinaryClassification.CrossValidate(data, estimator, numFolds: 5);
var aucs = cvResults.Select(r => r.metrics.Auc);
// Now let's train a model on the full dataset to help us get better results
var model = estimator.Fit(data);
// The dataset we have is skewed, as there are many more non-spam messages than spam messages.
// While our model is relatively good at detecting the difference, this skewness leads it to always
// say the message is not spam. We deal with this by lowering the threshold of the predictor. In reality,
// it is useful to look at the precision-recall curve to identify the best possible threshold.
var inPipe = new TransformerChain <ITransformer>(model.Take(model.Count() - 1).ToArray());
var lastTransformer = new BinaryPredictionTransformer <IPredictorProducing <float> >(mlContext, model.LastTransformer.Model, inPipe.GetOutputSchema(data.Schema), model.LastTransformer.FeatureColumn, threshold: 0.15f, thresholdColumn: DefaultColumnNames.Probability);
ITransformer[] parts = model.ToArray();
parts[parts.Length - 1] = lastTransformer;
var newModel = new TransformerChain <ITransformer>(parts);
// Create a PredictionFunction from our model
_predictor = newModel.MakePredictionFunction <SpamInput, SpamPrediction>(mlContext);
}
return(_predictor);
}
public CountrySalesForecastController(IOptionsSnapshot <AppSettings> appSettings,
PredictionFunction <CountryData, CountrySalesPrediction> countrySalesPredFunction,
ILogger <CountrySalesForecastController> logger
)
{
this.appSettings = appSettings.Value;
// Get injected Country Sales Prediction function
this.countrySalesPredFunction = countrySalesPredFunction;
this.logger = logger;
}
private static void PredictSimple(string name, float age, string gender, PredictionFunction <AgeRange, AgeRangePrediction> predictionFunction)
{
var example = new AgeRange()
{
Age = age,
Name = name,
Gender = gender
};
var prediction = predictionFunction.Predict(example);
Console.WriteLine($"Name: {example.Name}\t Age: {example.Age:00}\t Gender: {example.Gender}\t >> Predicted Label: {prediction.PredictedLabel}");
}
public ITransformer LoadModelFromZipFile(string modelPath)
{
using (var stream = new FileStream(modelPath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
TrainedModel = TransformerChain.LoadFrom(_mlContext, stream);
}
// Create prediction engine related to the loaded trained model
PredictionFunction = TrainedModel.MakePredictionFunction <TObservation, TPrediction>(_mlContext);
return(TrainedModel);
}
public static void ClassifyMessage(PredictionFunction <Input, Prediction> predictor, string message)
{
var input = new Input {
Message = message
};
var prediction = predictor.Predict(input);
var output = prediction.IsSpam
? "Spam"
: "Not Spam";
Console.WriteLine($"The message '{input.Message}' is '{output}'");
}
private bool LoadModel()
{
using (var stream = File.OpenRead(_modelName))
{
var env = new LocalEnvironment();
ITransformer loadedModel = TransformerChain.LoadFrom(env, stream);
_predictionFunction = loadedModel.MakePredictionFunction <PEModelData, PEPrediction>(env);
return(true);
}
}
public ModelScorer(MLContext mlContext, ITransformer trainedModel = null)
{
_mlContext = mlContext;
if (trainedModel != null)
{
//Keep the trainedModel passed through the constructor
TrainedModel = trainedModel;
// Create prediction engine related to the passed trained model
PredictionFunction = TrainedModel.MakePredictionFunction <TObservation, TPrediction>(_mlContext);
}
}
/// <summary>
/// Use your model to make a prediction
/// You can change these numbers to test different predictions
/// </summary>
/// <typeparam name="TSrc"></typeparam>
/// <typeparam name="TDst"></typeparam>
/// <param name="dataPath"></param>
/// <param name="parameters"></param>
/// <param name="inputData"></param>
/// <returns></returns>
public static TDst Predict <TSrc, TDst>(string dataPath, string[] parameters, TSrc inputData)
where TSrc : class
where TDst : class, new()
{
// Create a ML.NET environment
MLContext mlContext = new MLContext();
IDataView trainingDataView = mlContext.LoadTrainingData <TSrc>(dataPath, inputData);
EstimatorChain <KeyToValueMappingTransformer> learningPipeline = mlContext.GetLearningPipeline(parameters);
TransformerChain <KeyToValueMappingTransformer> model = trainingDataView.TrainModel(learningPipeline);
PredictionFunction <TSrc, TDst> prediction = model.MakePredictionFunction <TSrc, TDst>(mlContext);
TDst result = prediction.Predict(inputData);
return(result);
}
public static void VisualizeSomePredictions(MLContext mlContext,
string modelName,
string testDataLocation,
PredictionFunction <DemandObservation, DemandPrediction> predFunction,
int numberOfPredictions)
{
//Make a few prediction tests
// Make the provided number of predictions and compare with observed data from the test dataset
var testData = ReadSampleDataFromCsvFile(testDataLocation, numberOfPredictions);
for (int i = 0; i < numberOfPredictions; i++)
{
//Score
var resultprediction = predFunction.Predict(testData[i]);
Common.ConsoleHelper.PrintRegressionPredictionVersusObserved(resultprediction.PredictedCount.ToString(),
testData[i].Count.ToString());
}
}
public TPrediction Predict(TData dataSample)
{
//Get PredictionEngine object from the Object Pool
PredictionFunction <TData, TPrediction> predictionEngine = _predictionEnginePool.GetObject();
//Measure Predict() execution time
var watch = System.Diagnostics.Stopwatch.StartNew();
//Predict
TPrediction prediction = predictionEngine.Predict(dataSample);
//Stop measuring time
watch.Stop();
long elapsedMs = watch.ElapsedMilliseconds;
//Release used PredictionEngine object into the Object Pool
_predictionEnginePool.PutObject(predictionEngine);
return(prediction);
}
public void SetupIrisPipeline()
{
_irisExample = new IrisData()
{
SepalLength = 3.3f,
SepalWidth = 1.6f,
PetalLength = 0.2f,
PetalWidth = 5.1f,
};
string _irisDataPath = Program.GetInvariantCultureDataPath("iris.txt");
using (var env = new ConsoleEnvironment(seed: 1, conc: 1, verbose: false, sensitivity: MessageSensitivity.None, outWriter: EmptyWriter.Instance))
{
var reader = new TextLoader(env,
new TextLoader.Arguments()
{
Separator = "\t",
HasHeader = true,
Column = new[]
{
new TextLoader.Column("Label", DataKind.R4, 0),
new TextLoader.Column("SepalLength", DataKind.R4, 1),
new TextLoader.Column("SepalWidth", DataKind.R4, 2),
new TextLoader.Column("PetalLength", DataKind.R4, 3),
new TextLoader.Column("PetalWidth", DataKind.R4, 4),
}
});
IDataView data = reader.Read(new MultiFileSource(_irisDataPath));
var pipeline = new ConcatEstimator(env, "Features", new[] { "SepalLength", "SepalWidth", "PetalLength", "PetalWidth" })
.Append(new SdcaMultiClassTrainer(env, new SdcaMultiClassTrainer.Arguments {
NumThreads = 1, ConvergenceTolerance = 1e-2f
}, "Features", "Label"));
var model = pipeline.Fit(data);
_irisModel = model.MakePredictionFunction <IrisData, IrisPrediction>(env);
}
}
public void Train(string dest)
{
using (var env = new ConsoleEnvironment(verbose: false))
{
var args = new TextLoader.Arguments()
{
Separator = ",",
HasHeader = true,
Column = new TextLoader.Column[] {
new TextLoader.Column("Label", DataKind.R4, 0),
new TextLoader.Column("Sepal_length", DataKind.R4, 1),
new TextLoader.Column("Sepal_width", DataKind.R4, 2),
new TextLoader.Column("Petal_length", DataKind.R4, 3),
new TextLoader.Column("Petal_width", DataKind.R4, 4),
}
};
var reader = new TextLoader(env, args);
var concat = new ColumnConcatenatingEstimator(env,
"Features", "Sepal_length",
"Sepal_width", "Petal_length", "Petal_width");
var km = new MulticlassLogisticRegression(env, "Label", "Features");
var pipeline = concat.Append(km);
IDataView trainingDataView = reader.Read(new MultiFileSource(_dataset));
var model = pipeline.Fit(trainingDataView);
var obs = new IrisObservation()
{
Sepal_length = 3.3f,
Sepal_width = 1.6f,
Petal_length = 0.2f,
Petal_width = 5.1f,
};
_fct = model.MakePredictionFunction <IrisObservation, IrisPrediction>(env);
using (var stdest = File.OpenWrite(dest))
model.SaveTo(env, stdest);
}
}
private void ComparePredictions(PredictionFunction <IrisData, IrisPrediction> model)
{
IrisPrediction prediction = model.Predict(new IrisData()
{
SepalLength = 5.1f,
SepalWidth = 3.3f,
PetalLength = 1.6f,
PetalWidth = 0.2f,
});
Assert.Equal(1, prediction.PredictedLabels[0], 2);
Assert.Equal(0, prediction.PredictedLabels[1], 2);
Assert.Equal(0, prediction.PredictedLabels[2], 2);
prediction = model.Predict(new IrisData()
{
SepalLength = 6.4f,
SepalWidth = 3.1f,
PetalLength = 5.5f,
PetalWidth = 2.2f,
});
Assert.Equal(0, prediction.PredictedLabels[0], 2);
Assert.Equal(0, prediction.PredictedLabels[1], 2);
Assert.Equal(1, prediction.PredictedLabels[2], 2);
prediction = model.Predict(new IrisData()
{
SepalLength = 4.4f,
SepalWidth = 3.1f,
PetalLength = 2.5f,
PetalWidth = 1.2f,
});
Assert.Equal(.2, prediction.PredictedLabels[0], 1);
Assert.Equal(.8, prediction.PredictedLabels[1], 1);
Assert.Equal(0, prediction.PredictedLabels[2], 2);
}
protected IEnumerable <ImagePredictedLabelWithProbability> PredictDataUsingModel(string testLocation, string imagesFolder, string labelsLocation, PredictionFunction <ImageInputData, ImageNetPrediction> model)
{
ConsoleWriteHeader("Classificate images");
Console.WriteLine($"Images folder: {imagesFolder}");
Console.WriteLine($"Training file: {testLocation}");
Console.WriteLine($"Labels file: {labelsLocation}");
var labels = ModelHelpers.ReadLabels(labelsLocation);
/////////////////////////////////////////////////////////////////////////////////////
// IMAGE 1
// Predict label for "green-office-chair-test.jpg"
var image1 = new ImageInputData {
ImagePath = imagesFolder + "\\" + "green-office-chair-test.jpg"
};
var image1Probabilities = model.Predict(image1).PredictedLabels;
//Set a single label as predicted or even none if probabilities were lower than 70%
var image1BestLabelPrediction = new ImagePredictedLabelWithProbability()
{
ImagePath = image1.ImagePath,
};
(image1BestLabelPrediction.PredictedLabel, image1BestLabelPrediction.Probability) = GetBestLabel(labels, image1Probabilities);
image1BestLabelPrediction.ConsoleWrite();
yield return(image1BestLabelPrediction);
/////////////////////////////////////////////////////////////////////////////////////
// IMAGE 2
// Predict label for "high-metal-office-chair.jpg"
var image2 = new ImageInputData {
ImagePath = imagesFolder + "\\" + "high-metal-office-chair.jpg"
};
var image2Probabilities = model.Predict(image2).PredictedLabels;
//Set a single label as predicted or even none if probabilities were lower than 70%
var image2BestLabelPrediction = new ImagePredictedLabelWithProbability()
{
ImagePath = image2.ImagePath,
};
(image2BestLabelPrediction.PredictedLabel, image2BestLabelPrediction.Probability) = GetBestLabel(labels, image2Probabilities);
image2BestLabelPrediction.ConsoleWrite();
yield return(image1BestLabelPrediction);
}
protected IEnumerable <ImageNetData> PredictDataUsingModel(string testLocation, string imagesFolder, string labelsLocation, PredictionFunction <ImageNetData, ImageNetPrediction> model)
{
ConsoleWriteHeader("Classificate images");
Console.WriteLine($"Images folder: {imagesFolder}");
Console.WriteLine($"Training file: {testLocation}");
Console.WriteLine($"Labels file: {labelsLocation}");
var labels = ModelHelpers.ReadLabels(labelsLocation);
var testData = ImageNetData.ReadFromCsv(testLocation, imagesFolder);
foreach (var sample in testData)
{
var probs = model.Predict(sample).PredictedLabels;
var imageData = new ImageNetDataProbability()
{
ImagePath = sample.ImagePath,
Label = sample.Label
};
(imageData.PredictedLabel, imageData.Probability) = GetBestLabel(labels, probs);
imageData.ConsoleWrite();
yield return(imageData);
}
}
public PredictionsController(PredictionFunction <SearchData, FlatPrediction> predictionFn)
{
_predictionFn = predictionFn;
}
public ITransformer Train(IDataView trainingData)
{
TrainedModel = _trainingPipeline.Fit(trainingData);
PredictionFunction = TrainedModel.MakePredictionFunction <DemandObservation, DemandPrediction>(_mlcontext);
return(TrainedModel);
}
public void Init()
{
_model = CreatePredictionFunction();
}
