public async Task <TrainedModelPrediction> UseModelWithSingleItem(Shared.Models.PredictionModel predictionModel, string usersEmail)
{
// Step 1: download file from blob storage
var blobs = await _blobService.ListBlobs(BlobStorageService.TypeOfBlobUpload.ModelFile, usersEmail);
var singleBlob = blobs
.Where(a => a == predictionModel?.ModelId)
.FirstOrDefault();
// Step 2: get reference to downloaded blob
using (Stream stream = new MemoryStream())
{
var blobObject = await _blobService.DownloadBlob(usersEmail, singleBlob, stream);
stream.Seek(0, SeekOrigin.Begin);
await blobObject.CopyToAsync(stream);
var model = mlContext.Model.Load(stream);
PredictionEngine <TrainedModel, TrainedModelPrediction> predictionFunction = model.CreatePredictionEngine <TrainedModel, TrainedModelPrediction>(mlContext);
TrainedModel sampleStatement = new TrainedModel
{
Input = predictionModel.PredictionInput?.Input
};
var resultprediction = predictionFunction.Predict(sampleStatement);
return(resultprediction);
}
}
public override float Predict(ModelDataSet input)
{
if (TrainedModel == null)
{
throw new Exception("Must initialize the model before calling");
}
lock (TrainedModel)
{
// cache for reuse
if (PredictInput == null)
{
PredictInput = new float[input.Features()];
}
for (int i = 0; i < PredictInput.Length; i++)
{
PredictInput[i] = input.Feature(i);
}
using (var arr = InputArray.Create <float>(PredictInput))
{
return(TrainedModel.Predict(arr));
}
}
}
public IEnumerable <DemandPrediction> PredictBatch(IDataView inputDataView)
{
CheckTrained();
var predictions = TrainedModel.Transform(inputDataView);
return(predictions.AsEnumerable <DemandPrediction>(_mlcontext, reuseRowObject: false));
}
public RegressionEvaluator.Result Evaluate(IDataView testData)
{
CheckTrained();
var predictions = TrainedModel.Transform(testData);
var metrics = _mlcontext.Regression.Evaluate(predictions, "Count", "Score");
return(metrics);
}
public override void Save(string path)
{
if (TrainedModel == null)
{
throw new Exception("Must initialize the model before calling");
}
TrainedModel.Save(path);
}
public override void Save(string path)
{
if (TrainedModel == null)
{
throw new InvalidOperationException("Must train/load a model before saving");
}
TrainedModel.Save(path);
}
public async Task Save(ITransformer bestRunModel, MLContext mlContext, DataViewSchema schema, MulticlassClassificationMetrics metrics)
{
await using var ms = new MemoryStream();
mlContext.Model.Save(bestRunModel, schema, ms);
var trainedModel = new TrainedModel()
{
ModelData = ms.ToArray(),
Accuracy = metrics.MicroAccuracy
};
_context.TrainedModels.Add(trainedModel);
await _context.SaveChangesAsync();
}
public override ModelFitness Evaluate(List <ModelDataSet> data, ModelValue prediction)
{
if (TrainedModel == null)
{
throw new Exception("Must initialize the model before calling");
}
lock (TrainedModel)
{
#if ML_LEGACY
var testData = CollectionDataSource.Create(data);
var evaluator = new RegressionEvaluator();
var metrics = evaluator.Evaluate(TrainedModel, testData);
return(new ModelFitness()
{
RMS = metrics.Rms,
RSquared = metrics.RSquared
});
#else
var textLoader = GetTextLoader(Context, prediction);
var pathToData = "";
try
{
// ugh have to spill data to disk for it to work!
pathToData = WriteToDisk(data, prediction);
IDataView dataView = textLoader.Read(pathToData);
var predictions = TrainedModel.Transform(dataView);
var metrics = Context.Regression.Evaluate(predictions, label: "Label", score: "Score");
return(new ModelFitness()
{
RMS = metrics.Rms,
RSquared = metrics.RSquared
});
}
finally
{
// cleanup
if (!string.IsNullOrWhiteSpace(pathToData) && File.Exists(pathToData))
{
File.Delete(pathToData);
}
}
#endif
}
}
public override float Predict(float[] data)
{
if (TrainedModel == null)
{
throw new InvalidOperationException("Must train/load a model before predicting");
}
lock (TrainedModel)
{
using (var arr = InputArray.Create <float>(data))
{
return(TrainedModel.Predict(arr));
}
}
}
static void Main()
{
string assetsPath = Path.Combine(new FileInfo(typeof(Program).Assembly.Location).Directory.FullName, "assets");
var trainingImages = Path.GetFullPath("../../../assets/inputs/train"); // "C:\\repo\\Image-classification-transfer-learning\\grocery\\train2\\";
var testingImages = Path.GetFullPath("../../../../ImageClassification.Test/assets/test/thor");
var featurizerModel = Path.Combine(assetsPath, "inputs", "inception", "tensorflow_inception_graph.pb");
string trainedModelLocation = Path.GetFullPath("../../../imageClassifier.zip");
//Train model
try
{
var modelBuilder = new ModelBuilder(trainingImages, featurizerModel, trainedModelLocation);
modelBuilder.Train();
}
catch (Exception ex)
{
ConsoleHelpers.ConsoleWriteException(ex.Message);
}
//Test model
ConsoleHelpers.ConsoleWriteHeader("Test model with few sample images");
try
{
ConsoleHelpers.ConsoleWriteHeader("Load saved model");
TrainedModel model = new TrainedModel(trainedModelLocation);
ImagePrediction prediction = new ImagePrediction();
List <PredictionResult> results = new List <PredictionResult>();
List <ImageData> imageList = DataHelper.ReadFromFolder(testingImages);
foreach (ImageData image in imageList)
{
prediction = model.predictor.Predict(image);
PredictionResult result = new PredictionResult(Path.GetFileName(image.ImagePath).ToString(), prediction.PredictedLabelValue, prediction.Score.Max());
results.Add(result);
}
var output = JsonConvert.SerializeObject(results, Formatting.Indented);
Console.WriteLine(output);
}
catch (Exception ex)
{
ConsoleHelpers.ConsoleWriteException(ex.Message);
}
}
public override void Train(float[,] data, List <float> labels)
{
if (TrainedModel != null)
{
throw new InvalidOperationException("May only train/load a model once");
}
if (data.GetLength(0) != labels.Count)
{
throw new InvalidOperationException("Input data and label length must match");
}
var dataInput = InputArray.Create <float>(data);
var labelInput = InputArray.Create <float>(labels);
TrainedModel = RTrees.Create();
TrainedModel.Train(dataInput, SampleTypes.RowSample, labelInput);
}
public override void Save(string path)
{
if (TrainedModel == null)
{
throw new InvalidOperationException("Must train/load a model before saving");
}
#if ML_LEGACY
TrainedModel.WriteAsync(path).Wait();
#else
// save
using (var stream = File.Create(path))
{
Context.Model.Save(TrainedModel, InputSchema, stream);
}
#endif
}
// load
public ModelMLNet(string path)
{
#if ML_LEGACY
TrainedModel = PredictionModel.ReadAsync <ModelDataSet, ModelDataSetPrediction>(path).Result;
#else
Context = new MLContext();
// load
using (var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
TrainedModel = Context.Model.Load(stream);
}
// create the prediction function
PredictFunc = TrainedModel.MakePredictionFunction <ModelDataSet, ModelDataSetPrediction>(Context);
#endif
}
public override float Predict(DataSet data)
{
if (TrainedModel == null)
{
throw new InvalidOperationException("Must train/load a model before evaluating");
}
lock (TrainedModel)
{
#if ML_LEGACY
var result = TrainedModel.Predict(data);
return(result.Score);
#else
var result = PredictFunc.Predict(data);
return(result.Score);
#endif
}
}
public override float Predict(ModelDataSet data)
{
if (TrainedModel == null)
{
throw new Exception("Must initialize the model before calling");
}
lock (TrainedModel)
{
#if ML_LEGACY
var result = TrainedModel.Predict(data);
return(result.Score);
#else
var result = PredictFunc.Predict(data);
return(result.Score);
#endif
}
}
public int[][] GetConfusionMatrix(IEnumerable <IEnumerable <string> > testData)
{
var confusionMatrix = new int[ClassInfo.NominalOptionCount][];
for (int i = 0; i < ClassInfo.NominalOptionCount; i++)
{
confusionMatrix[i] = new int[ClassInfo.NominalOptionCount];
}
foreach (var row in testData)
{
var data = GetRowData(row, Attributes);
var originClass = data.ElementAt(ClassIndex);
var test = data.Where((x, i) => i != ClassIndex);
var estimatedClass =
ClassInfo.GetNominalOptionIndex(TrainedModel.GetEstimatedClass(test));
confusionMatrix[originClass][estimatedClass]++;
}
return(confusionMatrix);
}
// return r^2
public override double Evaluate(List <DataSet> data, List <float> labels = null)
{
if (TrainedModel == null)
{
throw new InvalidOperationException("Must train/load a model before evaluating");
}
lock (TrainedModel)
{
#if ML_LEGACY
var testData = CollectionDataSource.Create(data);
//var evaluator = new RegressionEvaluator();
//var metrics = evaluator.Evaluate(TrainedModel, testData);
return(0);
//return metrics.RSquared;
#else
var textLoader = GetTextLoader(Context);
var pathToData = "";
try
{
// ugh have to spill data to disk for it to work!
pathToData = WriteToDisk(data);
IDataView dataView = textLoader.Load(pathToData);
var predictions = TrainedModel.Transform(dataView);
var metrics = Context.Regression.Evaluate(predictions, labelColumnName: "Label", scoreColumnName: "Score");
return(metrics.RSquared);
}
finally
{
// cleanup
if (!string.IsNullOrWhiteSpace(pathToData) && File.Exists(pathToData))
{
File.Delete(pathToData);
}
}
#endif
}
}
public override void Save(string path)
{
if (TrainedModel == null)
{
throw new Exception("Must initialize the model before calling");
}
lock (TrainedModel)
{
#if ML_LEGACY
TrainedModel.WriteAsync(path).Wait();
#else
// save
using (var stream = File.Create(path))
{
TrainedModel.SaveTo(Context, stream);
}
#endif
}
}
public override ModelFitness Evaluate(List <ModelDataSet> data, ModelValue prediction)
{
if (TrainedModel == null)
{
throw new Exception("Must initialize the model before calling");
}
lock (TrainedModel)
{
var textLoader = GetTextLoader(Context, prediction);
var pathToData = "";
try
{
// ugh have to spill data to disk for it to work!
pathToData = WriteToDisk(data, prediction);
IDataView dataView = textLoader.Load(pathToData);
var predictions = TrainedModel.Transform(dataView);
var metrics = Context.Regression.Evaluate(predictions, labelColumnName: "Label", scoreColumnName: "Score");
return(new ModelFitness()
{
RMS = metrics.RootMeanSquaredError,
RSquared = metrics.RSquared
});
}
finally
{
// cleanup
if (!string.IsNullOrWhiteSpace(pathToData) && File.Exists(pathToData))
{
File.Delete(pathToData);
}
}
}
}
public ITransformer Train(IDataView trainingData)
{
TrainedModel = _trainingPipeline.Fit(trainingData);
PredictionFunction = TrainedModel.MakePredictionFunction <DemandObservation, DemandPrediction>(_mlcontext);
return(TrainedModel);
}
// train
public ModelOpenCV(List <ModelDataSet> input, ModelValue prediction)
{
if (input == null || input.Count == 0)
{
throw new Exception("Must have valid input");
}
// convert features into proper form
var features = new float[input.Count, input[0].Features()];
var labels = new float[input.Count];
for (int i = 0; i < input.Count; i++)
{
for (int j = 0; j < input[i].Features(); j++)
{
features[i, j] = input[i].Feature(j);
}
switch (prediction)
{
case ModelValue.Action: labels[i] = input[i].Action; break;
case ModelValue.Angle: labels[i] = input[i].FaceAngle; break;
case ModelValue.XY: labels[i] = input[i].MoveAngle; break;
default: throw new Exception("Unknown prediction type : " + prediction);
}
}
// train
var labelInput = InputArray.Create <float>(labels);
var dataInput = InputArray.Create <float>(features);
TrainedModel = RTrees.Create();
TrainedModel.RegressionAccuracy = 0.00001f;
// RTrees.MaxDepath (r^2)
// default - action 0.3424, xy 0.1735, angle 0.2208
// 5 -
// 20 - action 0.6482, xy 0.5912, angle 0.6414 (new default)
// 100 - action 0.6408, xy 0.5914, angle 0.6419
TrainedModel.MaxDepth = 20;
// RTress.MinSampleCount
// default(10) - see 20 above
// 1 - actions 0.6625, xy 0.5077, angle 0.6376
// 50 - actions 0.6464, xy 0.5627, angle 0.6217
//TrainedModel.MinSampleCount = 1;
// fails
//TrainedModel = LogisticRegression.Create();
// fails
// TrainedModel = DTrees.Create();
// failed
//TrainedModel = SVM.Create();
//TrainedModel.KernelType = SVM.KernelTypes.Linear;
//TrainedModel.Type = SVM.Types.NuSvr;
//TrainedModel.C = 1;
//TrainedModel.P = 0.01;
//TrainedModel.Gamma = 10f;
//TrainedModel.Degree = 0.1;
//TrainedModel.Coef0 = 0;
//TrainedModel.Nu = 0.1;
TrainedModel.Train(dataInput, SampleTypes.RowSample, labelInput);
}
