public async Task <IDictionary <string, float> > EvaluateAsync(SoftwareBitmap bitmap)
{
var videoFrame = VideoFrame.CreateWithSoftwareBitmap(bitmap);
var imageFeatureValue = ImageFeatureValue.CreateFromVideoFrame(videoFrame);
var input = new SmartInkModelInput()
{
data = imageFeatureValue
};
var output = new SmartInkModelOutput();
_binding.Bind("data", input.data);
_binding.Bind("classLabel", output.ClassLabel);
_binding.Bind("loss", output.Loss);
LearningModelEvaluationResult result = await _session.EvaluateAsync(_binding, "0");
output.ClassLabel = result.Outputs["classLabel"] as TensorString;//).GetAsVectorView()[0];
output.Loss = result.Outputs["loss"] as IList <IDictionary <string, float> >;
var dict = new Dictionary <string, float>();
foreach (var key in output.Loss[0].Keys)
{
dict.Add(key, output.Loss[0][key]);
}
return(dict);
}
private unsafe LearningModelBinding EvaluateContrastAndBrightnessSession(object input, object output)
{
var slope = Math.Tan(ContrastMaxSlider.Value * 3.14159 / 2);
var yintercept = -255 * (ContrastMinSlider.Value * 2 - 1);
if (yintercept < 0)
{
// it was the x-intercept
yintercept = slope * yintercept;
}
var binding = new LearningModelBinding(contrastEffectSession_);
binding.Bind("Input", input);
binding.Bind("Slope", TensorFloat.CreateFromArray(new long[] { 1 }, new float[] { (float)slope }));
binding.Bind("YIntercept", TensorFloat.CreateFromArray(new long[] { 1 }, new float[] { (float)yintercept }));
var outputBindProperties = new PropertySet();
outputBindProperties.Add("DisableTensorCpuSync", PropertyValue.CreateBoolean(true));
binding.Bind("Output", output, outputBindProperties);
EvaluateInternal(contrastEffectSession_, binding);
return(binding);
}
private async Task LoadAndEvaluateModelAsync(VideoFrame _inputFrame, string _modelFileName)
{
LearningModelBinding _binding = null;
VideoFrame _outputFrame = null;
LearningModelSession _session;
try
{
//Load and create the model
if (_model == null)
{
var modelFile =
await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///{_modelFileName}"));
_model = await LearningModel.LoadFromStorageFileAsync(modelFile);
}
// Create the evaluation session with the model
_session = new LearningModelSession(_model);
// Get input and output features of the model
var inputFeatures = _model.InputFeatures.ToList();
var outputFeatures = _model.OutputFeatures.ToList();
// Create binding and then bind input/ output features
_binding = new LearningModelBinding(_session);
_inputImageDescriptor =
inputFeatures.FirstOrDefault(feature => feature.Kind == LearningModelFeatureKind.Tensor) as TensorFeatureDescriptor;
_outputTensorDescriptor =
outputFeatures.FirstOrDefault(feature => feature.Kind == LearningModelFeatureKind.Tensor) as TensorFeatureDescriptor;
TensorFloat outputTensor = TensorFloat.Create(_outputTensorDescriptor.Shape);
ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(_inputFrame);
// Bind inputs +outputs
_binding.Bind(_inputImageDescriptor.Name, imageTensor);
_binding.Bind(_outputTensorDescriptor.Name, outputTensor);
// Evaluate and get the results
var results = await _session.EvaluateAsync(_binding, "test");
Debug.WriteLine("ResultsEvaluated: " + results.ToString());
var outputTensorList = outputTensor.GetAsVectorView();
var resultsList = new List <float>(outputTensorList.Count);
for (int i = 0; i < outputTensorList.Count; i++)
{
resultsList.Add(outputTensorList[i]);
}
}
catch (Exception ex)
{
Debug.WriteLine($"error: {ex.Message}");
_model = null;
}
}
public async Task <TensorFloat> EvaluateAsync(TensorFloat input)
{
binding.Bind(inName, input);
binding.Bind(outName, TensorFloat.Create(new long[] { 1, 1, InHeight, OutHeight }));
var result = await session.EvaluateAsync(binding, inName);
return(result.Outputs[outName] as TensorFloat);
}
private void SampleInputsGridView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
var gridView = sender as GridView;
var thumbnail = gridView.SelectedItem as WinMLSamplesGallery.Controls.Thumbnail;
if (thumbnail != null)
{
var image = thumbnail.ImageUri;
var file = StorageFile.GetFileFromApplicationUriAsync(new Uri(image)).GetAwaiter().GetResult();
var softwareBitmap = CreateSoftwareBitmapFromStorageFile(file);
tensorizationSession_ =
CreateLearningModelSession(
TensorizationModels.ReshapeFlatBufferNHWC(
1,
4,
softwareBitmap.PixelHeight,
softwareBitmap.PixelWidth,
416,
416));
// Tensorize
var stream = file.OpenAsync(FileAccessMode.Read).GetAwaiter().GetResult();
var decoder = BitmapDecoder.CreateAsync(stream).GetAwaiter().GetResult();
var bitmap = decoder.GetSoftwareBitmapAsync(BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied).GetAwaiter().GetResult();
var pixelDataProvider = decoder.GetPixelDataAsync().GetAwaiter().GetResult();
var bytes = pixelDataProvider.DetachPixelData();
var buffer = bytes.AsBuffer(); // Does this do a copy??
var inputRawTensor = TensorUInt8Bit.CreateFromBuffer(new long[] { 1, buffer.Length }, buffer);
// 3 channel NCHW
var tensorizeOutput = TensorFloat.Create(new long[] { 1, 416, 416, 3 });
var b = new LearningModelBinding(tensorizationSession_);
b.Bind(tensorizationSession_.Model.InputFeatures[0].Name, inputRawTensor);
b.Bind(tensorizationSession_.Model.OutputFeatures[0].Name, tensorizeOutput);
tensorizationSession_.Evaluate(b, "");
// Resize
var resizeBinding = new LearningModelBinding(_session);
resizeBinding.Bind(_session.Model.InputFeatures[0].Name, tensorizeOutput);
var results = _session.Evaluate(resizeBinding, "");
var output1 = results.Output(0) as TensorFloat;
var data = output1.GetAsVectorView();
var detections = ParseResult(data.ToList <float>().ToArray());
Comparer cp = new Comparer();
detections.Sort(cp);
var final = NMS(detections);
RenderImageInMainPanel(softwareBitmap);
}
}
public async Task <hangulOutput> EvaluateAsync(hangulInput input)
{
binding.Bind("input:0", input.input00);
binding.Bind("keep_prob:0", input.keep_prob);
var result = await session.EvaluateAsync(binding, "0");
var output = new hangulOutput();
output.output00 = result.Outputs["output:0"] as TensorFloat;
return(output);
}
public async Task <ModelOutput> EvaluateAsync(OnnxModelInput input)
{
var output = new ModelOutput();
var binding = new LearningModelBinding(_session);
binding.Bind("data", input.Data);
binding.Bind("model_outputs0", output.Model_outputs0);
var evalResult = await _session.EvaluateAsync(binding, "0");
return(output);
}
public async Task <ModelOutput> EvaluateAsync(OnnxModelInput input)
{
var output = new ModelOutput();
var binding = new LearningModelBinding(_session);
binding.Bind("data", input.Data);
binding.Bind("classLabel", output.ClassLabel);
binding.Bind("loss", output.Loss);
var evalResult = await _session.EvaluateAsync(binding, "0");
return(output);
}
/// <summary>
/// Evaluate the model
/// </summary>
/// <param name="input">The VideoFrame to evaluate</param>
/// <returns></returns>
public async Task <ONNXModelOutput> EvaluateAsync(ONNXModelInput input)
{
var output = new ONNXModelOutput();
var binding = new LearningModelBinding(_session);
binding.Bind("data", input.data);
binding.Bind("classLabel", output.classLabel);
binding.Bind("loss", output.loss);
LearningModelEvaluationResult result = await _session.EvaluateAsync(binding, "0");
return(output);
}
/// <summary>
/// Detect objects from the given image.
/// The input image must be 416x416.
/// </summary>
public async Task <IList <PredictionModel> > PredictImageAsync(VideoFrame image)
{
var output = new modelOutput();
var imageFeature = ImageFeatureValue.CreateFromVideoFrame(image);
var bindings = new LearningModelBinding(Session);
bindings.Bind("data", imageFeature);
bindings.Bind("model_outputs0", output.Model_outputs0);
var result = await Session.EvaluateAsync(bindings, "0");
return(Postprocess(output.Model_outputs0));
}
public async Task <modelOutput> EvaluateAsync(modelInput input)
{
var output = new modelOutput();
binding.Bind("data", input.data);
binding.Bind("classLabel", output.ClassLabel);
binding.Bind("loss", output.Loss);
var result = await session.EvaluateAsync(binding, "0");
output.ClassLabel = result.Outputs["classLabel"] as TensorString;
output.Loss = result.Outputs["loss"] as List <IDictionary <string, float> >;
return(output);
}
public async Task<ShuffleNetOutput> EvaluateAsync(ShuffleNetInput input)
{
binding.Bind("gpu_0/data_0", input.gpu_00data_0);
var result = await session.EvaluateAsync(binding, "0");
var output = new ShuffleNetOutput();
output.gpu_00softmax_1 = result.Outputs["gpu_0/softmax_1"] as TensorFloat;
return output;
}
public async Task <MultiObjectDetectionModelv8Output> EvaluateAsync(MultiObjectDetectionModelv8Input input)
{
var output = new MultiObjectDetectionModelv8Output();
if (input != null)
{
binding.Bind("image", input.Image);
var result = await session.EvaluateAsync(binding, "0");
output.Grid = result.Outputs["grid"] as TensorFloat;
}
else
{
throw new NullReferenceException();
}
return(output);
}
public async Task <taxiFarePredOutput> EvaluateAsync(taxiFarePredInput input)
{
binding.Bind("PassengerCount", input.PassengerCount);
binding.Bind("TripTime", input.TripTime);
binding.Bind("TripDistance", input.TripDistance);
binding.Bind("FareAmount", input.FareAmount);
var result = await session.EvaluateAsync(binding, "0");
var output = new taxiFarePredOutput();
output.PassengerCount0 = result.Outputs["PassengerCount0"] as TensorFloat;
output.TripTime0 = result.Outputs["TripTime0"] as TensorFloat;
output.TripDistance0 = result.Outputs["TripDistance0"] as TensorFloat;
output.FareAmount0 = result.Outputs["FareAmount0"] as TensorFloat;
output.Features0 = result.Outputs["Features0"] as TensorFloat;
output.Score0 = result.Outputs["Score0"] as TensorFloat;
return(output);
}
public async Task <model1Output> EvaluateAsync(model1Input input)
{
binding.Bind("dense_1_input", input.dense_1_input);
var result = await session.EvaluateAsync(binding, "0");
var output = new model1Output();
output.activation_10Softmax00 = result.Outputs["activation_1/Softmax:0"] as TensorFloat;
return(output);
}
public async Task <modelOutput> EvaluateAsync(modelInput input)
{
binding.Bind("Input3", input.Input3);
var result = await session.EvaluateAsync(binding, "0");
var output = new modelOutput();
output.Plus692_Output_0 = result.Outputs["Plus692_Output_0"] as TensorFloat;
return(output);
}
/// <summary>
/// Detect objects from the given image.
/// The input image must be 416x416.
/// </summary>
public async Task <IList <PredictionModel> > PredictImageAsync(VideoFrame image)
{
var imageFeature = ImageFeatureValue.CreateFromVideoFrame(image);
var bindings = new LearningModelBinding(this.session);
bindings.Bind("data", imageFeature);
var result = await this.session.EvaluateAsync(bindings, "");
return(Postprocess(result.Outputs["model_outputs0"] as TensorFloat));
}
public async Task <ImageClassifierOutput> EvaluateAsync(ImageClassifierInput input)
{
binding.Bind("modelInput", input.modelInput);
var result = await session.EvaluateAsync(binding, "0");
var output = new ImageClassifierOutput();
output.modelOutput = result.Outputs["modelOutput"] as TensorFloat;
return(output);
}
public async Task <Inceptionv3_convertedOutput> EvaluateAsync(Inceptionv3_convertedInput input)
{
binding.Bind("input_1_0", input.input_1_0);
var result = await session.EvaluateAsync(binding, "0");
var output = new Inceptionv3_convertedOutput();
output.dense_2_Softmax_01 = result.Outputs["dense_2_Softmax_01"] as TensorFloat;
return(output);
}
public async Task <mnistOutput> EvaluateAsync(mnistInput input)
{
binding.Bind("fc1x", input.fc1x);
var result = await session.EvaluateAsync(binding, "0");
var output = new mnistOutput();
output.activation3y = result.Outputs["activation3y"] as TensorFloat;
return(output);
}
public async Task <AlexNetOutput> EvaluateAsync(AlexNetInput input)
{
binding.Bind("data_0", input.data_0);
var result = await session.EvaluateAsync(binding, "0");
var output = new AlexNetOutput();
output.prob_1 = result.Outputs["prob_1"] as TensorFloat;
return(output);
}
public async Task <mnistOutput> EvaluateAsync(mnistInput input)
{
binding.Bind("input_placeholer:0", input.input_placeholer00);
var result = await session.EvaluateAsync(binding, "0");
var output = new mnistOutput();
output.stage_30mid_conv70BiasAdd00 = result.Outputs["stage_3/mid_conv7/BiasAdd:0"] as TensorFloat;
return(output);
}
public async Task <HandwriteOutput> EvaluateAsync(HandwriteInput input)
{
binding.Bind("Input3", input.Input3);
var result = await session.EvaluateAsync(binding, "0");
var output = new HandwriteOutput();
output.Plus214_Output_0 = result.Outputs["Plus214_Output_0"] as TensorFloat;
return(output);
}
public async Task <modelOutput> EvaluateAsync(modelInput input)
{
binding.Bind("data_0", input.data_0);
var result = await session.EvaluateAsync(binding, "0");
var output = new modelOutput();
output.softmaxout_1 = result.Outputs["softmaxout_1"] as TensorFloat;
return(output);
}
public async Task <sthv2_tpnOutput> EvaluateAsync(sthv2_tpnInput input)
{
binding.Bind("input", input.input);
var result = await session.EvaluateAsync(binding, "0");
var output = new sthv2_tpnOutput();
output.output = result.Outputs["output"] as TensorFloat;
return(output);
}
public async Task <mnistOutput> EvaluateAsync(mnistInput input)
{
binding.Bind("port", input.port);
var result = await session.EvaluateAsync(binding, "0");
var output = new mnistOutput();
output.dense3port = result.Outputs["dense3port"] as TensorFloat;
return(output);
}
public async Task <modelOutput> EvaluateAsync(modelInput input)
{
binding.Bind("data", input.data);
var result = await session.EvaluateAsync(binding, "0");
var output = new modelOutput();
output.model_outputs0 = result.Outputs["model_outputs0"] as TensorFloat;
return(output);
}
public async Task <resnet100Output> EvaluateAsync(resnet100Input input)
{
binding.Bind("data", input.data);
var result = await session.EvaluateAsync(binding, "0");
var output = new resnet100Output();
output.fc1 = result.Outputs["fc1"] as TensorFloat;
return(output);
}
public async Task <pointilismOutput> EvaluateAsync(pointilismInput input)
{
binding.Bind("input1", input.input1);
var result = await session.EvaluateAsync(binding, "0");
var output = new pointilismOutput();
output.output1 = result.Outputs["output1"] as TensorFloat;
return(output);
}
public async Task <Output> EvaluateAsync(Input input)
{
binding.Bind("image", input.image);
var result = await session.EvaluateAsync(binding, "0");
var output = new Output();
output.grid = result.Outputs["grid"] as TensorFloat;
return(output);
}
