internal static NamedOnnxValue CreateNamedOnnxValueFromRawData <T>(string name, byte[] rawData, int elemWidth, int[] dimensions)
{
T[] typedArr = new T[rawData.Length / elemWidth];
var typeOf = typeof(T);
if (typeOf == typeof(Float16) || typeOf == typeof(BFloat16))
{
using (var memSrcHandle = new Memory <byte>(rawData).Pin())
using (var memDstHandle = new Memory <T>(typedArr).Pin())
{
unsafe
{
Buffer.MemoryCopy(memSrcHandle.Pointer, memDstHandle.Pointer, typedArr.Length * elemWidth, rawData.Length);
}
}
}
else
{
Buffer.BlockCopy(rawData, 0, typedArr, 0, rawData.Length);
}
var dt = new DenseTensor <T>(typedArr, dimensions);
return(NamedOnnxValue.CreateFromTensor <T>(name, dt));
}
static void UseApi()
{
string basepath = "..\\..\\..\\testdata\\";
string modelPath = basepath + "squeezenet.onnx";
Debug.Assert(File.Exists(modelPath));
// Optional : Create session options and set the graph optimization level for the session
SessionOptions options = new SessionOptions();
options.GraphOptimizationLevel = GraphOptimizationLevel.ORT_ENABLE_EXTENDED;
using (var session = new InferenceSession(modelPath, options))
{
var inputMeta = session.InputMetadata;
var container = new List <NamedOnnxValue>();
float[] inputData = LoadTensorFromFile(basepath + "bench.in"); // this is the data for only one input tensor for this model
foreach (var name in inputMeta.Keys)
{
var tensor = new DenseTensor <float>(inputData, inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
// Run the inference
using (var results = session.Run(container)) // results is an IDisposableReadOnlyCollection<DisposableNamedOnnxValue> container
{
// dump the results
foreach (var r in results)
{
Console.WriteLine("Output for {0}", r.Name);
Console.WriteLine(r.AsTensor <float>().GetArrayString());
}
}
}
}
public static void Main(string[] args)
{
// Read paths
string modelFilePath = args[0];
string imageFilePath = args[1];
string outImageFilePath = args[2];
// Read image
using Image <Rgb24> image = Image.Load <Rgb24>(imageFilePath);
// Resize image
float ratio = 800f / Math.Min(image.Width, image.Height);
image.Mutate(x => x.Resize((int)(ratio * image.Width), (int)(ratio * image.Height)));
// Preprocess image
var paddedHeight = (int)(Math.Ceiling(image.Height / 32f) * 32f);
var paddedWidth = (int)(Math.Ceiling(image.Width / 32f) * 32f);
Tensor <float> input = new DenseTensor <float>(new[] { 3, paddedHeight, paddedWidth });
var mean = new[] { 102.9801f, 115.9465f, 122.7717f };
image.ProcessPixelRows(accessor =>
{
for (int y = paddedHeight - accessor.Height; y < accessor.Height; y++)
{
Span <Rgb24> pixelSpan = accessor.GetRowSpan(y);
for (int x = paddedWidth - accessor.Width; x < accessor.Width; x++)
{
input[0, y, x] = pixelSpan[x].B - mean[0];
input[1, y, x] = pixelSpan[x].G - mean[1];
input[2, y, x] = pixelSpan[x].R - mean[2];
}
}
});
// Setup inputs and outputs
var inputs = new List <NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor("image", input)
};
// Run inference
using var session = new InferenceSession(modelFilePath);
using IDisposableReadOnlyCollection <DisposableNamedOnnxValue> results = session.Run(inputs);
// Postprocess to get predictions
var resultsArray = results.ToArray();
float[] boxes = resultsArray[0].AsEnumerable <float>().ToArray();
long[] labels = resultsArray[1].AsEnumerable <long>().ToArray();
float[] confidences = resultsArray[2].AsEnumerable <float>().ToArray();
var predictions = new List <Prediction>();
var minConfidence = 0.7f;
for (int i = 0; i < boxes.Length - 4; i += 4)
{
var index = i / 4;
if (confidences[index] >= minConfidence)
{
predictions.Add(new Prediction
{
Box = new Box(boxes[i], boxes[i + 1], boxes[i + 2], boxes[i + 3]),
Label = LabelMap.Labels[labels[index]],
Confidence = confidences[index]
});
}
}
// Put boxes, labels and confidence on image and save for viewing
using var outputImage = File.OpenWrite(outImageFilePath);
Font font = SystemFonts.CreateFont("Arial", 16);
foreach (var p in predictions)
{
image.Mutate(x =>
{
x.DrawLines(Color.Red, 2f, new PointF[] {
new PointF(p.Box.Xmin, p.Box.Ymin),
new PointF(p.Box.Xmax, p.Box.Ymin),
new PointF(p.Box.Xmax, p.Box.Ymin),
new PointF(p.Box.Xmax, p.Box.Ymax),
new PointF(p.Box.Xmax, p.Box.Ymax),
new PointF(p.Box.Xmin, p.Box.Ymax),
new PointF(p.Box.Xmin, p.Box.Ymax),
new PointF(p.Box.Xmin, p.Box.Ymin)
});
x.DrawText($"{p.Label}, {p.Confidence:0.00}", font, Color.White, new PointF(p.Box.Xmin, p.Box.Ymin));
});
}
image.SaveAsJpeg(outputImage);
}
/// <summary>
/// Returns face detection results.
/// </summary>
/// <param name="image">Bitmap</param>
/// <returns>Rectangles</returns>
public Rectangle[] Forward(Bitmap image)
{
var size = new Size(320, 240);
using var clone = Imaging.Resize(image, size);
int width = clone.Width;
int height = clone.Height;
var inputMeta = _session.InputMetadata;
var name = inputMeta.Keys.ToArray()[0];
// pre-processing
var dimentions = new int[] { 1, 3, height, width };
var tensors = clone.ToFloatTensor(true);
tensors.Operator(new float[] { 127.0f, 127.0f, 127.0f }, Vector.Sub);
tensors.Operator(128, Vector.Div);
var inputData = tensors.Merge(true);
// session run
var t = new DenseTensor <float>(inputData, dimentions);
var inputs = new List <NamedOnnxValue> {
NamedOnnxValue.CreateFromTensor(name, t)
};
var results = _session.Run(inputs).ToArray();
var confidences = results[0].AsTensor <float>().ToArray();
var boxes = results[1].AsTensor <float>().ToArray();
var length = confidences.Length;
// post-proccessing
var boxes_picked = new List <Rectangle>();
for (int i = 0, j = 0; i < length; i += 2, j += 4)
{
if (confidences[i + 1] > ConfidenceThreshold)
{
boxes_picked.Add(
Imaging.ToBox(
Rectangle.FromLTRB
(
(int)(boxes[j + 0] * image.Width),
(int)(boxes[j + 1] * image.Height),
(int)(boxes[j + 2] * image.Width),
(int)(boxes[j + 3] * image.Height)
)));
}
}
// non-max suppression
length = boxes_picked.Count;
for (int i = 0; i < length; i++)
{
var first = boxes_picked[i];
for (int j = i + 1; j < length; j++)
{
var second = boxes_picked[j];
var iou = Imaging.IoU(first, second);
if (iou > NmsThreshold)
{
boxes_picked.RemoveAt(j);
length = boxes_picked.Count;
j--;
}
}
}
// dispose
foreach (var result in results)
{
result.Dispose();
}
return(boxes_picked.ToArray());
}
//===========================================================================================//
public static async Task RecognitionAsync(IEnumerable <string> imags)
{
var images = imags.ToArray();
tasks = new Task[images.Length];
try
{
for (int i = 0; i < images.Count(); i++)
{
tasks[i] = Task.Factory.StartNew((imagePath) =>
{
Image <Rgb24> image = Image.Load <Rgb24>((string)imagePath, out IImageFormat format);
Stream imageStream = new MemoryStream();
image.Mutate(x =>
{
x.Resize(new ResizeOptions
{
Size = new Size(224, 224),
Mode = ResizeMode.Crop
});
});
image.Save(imageStream, format);
Tensor <float> input = new DenseTensor <float>(new[] { 1, 3, 224, 224 });
var mean = new[] { 0.485f, 0.456f, 0.406f };
var stddev = new[] { 0.229f, 0.224f, 0.225f };
for (int y = 0; y < image.Height; y++)
{
Span <Rgb24> pixelSpan = image.GetPixelRowSpan(y);
for (int x = 0; x < image.Width; x++)
{
input[0, 0, y, x] = ((pixelSpan[x].R / 255f) - mean[0]) / stddev[0];
input[0, 1, y, x] = ((pixelSpan[x].G / 255f) - mean[1]) / stddev[1];
input[0, 2, y, x] = ((pixelSpan[x].B / 255f) - mean[2]) / stddev[2];
}
}
List <NamedOnnxValue> inputs = new List <NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor("data", input)
};
var session = new InferenceSession(onnxModelPath);
IDisposableReadOnlyCollection <DisposableNamedOnnxValue> results = session.Run(inputs);
if (token.IsCancellationRequested)
{
return;
}
IEnumerable <float> output = results.First().AsEnumerable <float>();
float sum = output.Sum(x => (float)Math.Exp(x));
IEnumerable <float> softmax = output.Select(x => (float)Math.Exp(x) / sum);
IEnumerable <Prediction> top1 = softmax.Select((x, i) => new Prediction {
Label = LabelMap.Labels[i], Confidence = x
})
.OrderByDescending(x => x.Confidence)
.Take(1);
Prediction prediction = top1.First();
prediction.Path = (string)imagePath;
if (token.IsCancellationRequested)
{
return;
}
Result?.Invoke(prediction);
session.Dispose();
image.Dispose();
imageStream.Dispose();
}, images[i], token);
}
await Task.WhenAll(tasks);
}
catch (OperationCanceledException e)
{
Trace.WriteLine($"{nameof(OperationCanceledException)} thrown with message: {e.Message}");
}
}
public static void Main(string[] args)
{
// Read paths
string modelFilePath = args[0];
string imageFilePath = args[1];
// Read image
using Image <Rgb24> image = Image.Load <Rgb24>(imageFilePath);
// Resize image
image.Mutate(x =>
{
x.Resize(new ResizeOptions
{
Size = new Size(224, 224),
Mode = ResizeMode.Crop
});
});
// Preprocess image
Tensor <float> input = new DenseTensor <float>(new[] { 1, 3, 224, 224 });
var mean = new[] { 0.485f, 0.456f, 0.406f };
var stddev = new[] { 0.229f, 0.224f, 0.225f };
image.ProcessPixelRows(accessor =>
{
for (int y = 0; y < accessor.Height; y++)
{
Span <Rgb24> pixelSpan = accessor.GetRowSpan(y);
for (int x = 0; x < accessor.Width; x++)
{
input[0, 0, y, x] = ((pixelSpan[x].R / 255f) - mean[0]) / stddev[0];
input[0, 1, y, x] = ((pixelSpan[x].G / 255f) - mean[1]) / stddev[1];
input[0, 2, y, x] = ((pixelSpan[x].B / 255f) - mean[2]) / stddev[2];
}
}
});
// Setup inputs
var inputs = new List <NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor("data", input)
};
// Run inference
using var session = new InferenceSession(modelFilePath);
using IDisposableReadOnlyCollection <DisposableNamedOnnxValue> results = session.Run(inputs);
// Postprocess to get softmax vector
IEnumerable <float> output = results.First().AsEnumerable <float>();
float sum = output.Sum(x => (float)Math.Exp(x));
IEnumerable <float> softmax = output.Select(x => (float)Math.Exp(x) / sum);
// Extract top 10 predicted classes
IEnumerable <Prediction> top10 = softmax.Select((x, i) => new Prediction {
Label = LabelMap.Labels[i], Confidence = x
})
.OrderByDescending(x => x.Confidence)
.Take(10);
// Print results to console
Console.WriteLine("Top 10 predictions for ResNet50 v2...");
Console.WriteLine("--------------------------------------------------------------");
foreach (var t in top10)
{
Console.WriteLine($"Label: {t.Label}, Confidence: {t.Confidence}");
}
}
private void button1_Click(object sender, EventArgs e)
{
label1.Text = string.Empty;
pictureBox1.Image = null;
pictureBox1.Refresh();
bool isSuccess = false;
try
{
pictureBox1.Load(textBox1.Text);
isSuccess = true;
}
catch (Exception ex)
{
MessageBox.Show($"读取图片时出现错误：{ex.Message}");
throw;
}
if (isSuccess)
{
// 图片加载成功后，从图片控件中取出224*224的位图对象
Bitmap bitmap = new Bitmap(pictureBox1.Image, imageSize, imageSize);
float[] imageArray = new float[imageSize * imageSize * 3];
// 按照先行后列的方式依次取出图片的每个像素值
for (int y = 0; y < imageSize; y++)
{
for (int x = 0; x < imageSize; x++)
{
var color = bitmap.GetPixel(x, y);
// 使用Netron查看模型的输入发现
// 需要依次放置224 *224的蓝色分量、224*224的绿色分量、224*224的红色分量
imageArray[y * imageSize + x] = color.B;
imageArray[y * imageSize + x + 1 * imageSize * imageSize] = color.G;
imageArray[y * imageSize + x + 2 * imageSize * imageSize] = color.R;
}
}
string modelPath = AppDomain.CurrentDomain.BaseDirectory + "BearModel.onnx";
using (var session = new InferenceSession(modelPath))
{
var container = new List <NamedOnnxValue>();
// 用Netron看到需要的输入类型是float32[None,3,224,224]
// 第一维None表示可以传入多张图片进行推理
// 这里只使用一张图片，所以使用的输入数据尺寸为[1, 3, 224, 224]
var shape = new int[] { 1, 3, imageSize, imageSize };
var tensor = new DenseTensor <float>(imageArray, shape);
// 支持多个输入，对于mnist模型，只需要一个输入，输入的名称是data
container.Add(NamedOnnxValue.CreateFromTensor <float>("data", tensor));
// 推理
var results = session.Run(container);
// 输出结果有两个，classLabel和loss，这里只关心classLabel
var label = results.FirstOrDefault(item => item.Name == "classLabel")? // 取出名为classLabel的输出
.AsTensor <string>()?
.FirstOrDefault(); // 支持多张图片同时推理，这里只推理了一张，取第一个结果值
// 显示在控件中
label3.Text = label;
}
}
}
private void Form1_Load(object sender, EventArgs e)
{
// params
var threshold = 0.0f;
var c = Color.Yellow;
var font = new Font("Arial", 22);
// inference session
Console.WriteLine("Starting inference session...");
var tic = Environment.TickCount;
var session = new InferenceSession(model);
var inputMeta = session.InputMetadata;
var name = inputMeta.Keys.ToArray()[0];
var labels = File.ReadAllLines(prototxt);
Console.WriteLine("Session started in " + (Environment.TickCount - tic) + " mls.");
// image
Console.WriteLine("Creating image tensor...");
tic = Environment.TickCount;
var image = new Bitmap(file, false);
var width = image.Width;
var height = image.Height;
var dimentions = new int[] { 1, height, width, 3 };
var inputData = Onnx.ToTensor(image);
Console.WriteLine("Tensor was created in " + (Environment.TickCount - tic) + " mls.");
// prediction
Console.WriteLine("Detecting objects...");
tic = Environment.TickCount;
var t1 = new DenseTensor <byte>(inputData, dimentions);
var inputs = new List <NamedOnnxValue>()
{
NamedOnnxValue.CreateFromTensor(name, t1)
};
var results = session.Run(inputs).ToArray();
// dump the results
foreach (var r in results)
{
Console.WriteLine(r.Name + "\n");
Console.WriteLine(r.AsTensor <float>().GetArrayString());
}
Console.WriteLine("Detecting was finished in " + (Environment.TickCount - tic) + " mls.");
// drawing results
Console.WriteLine("Drawing inference results...");
tic = Environment.TickCount;
var detection_boxes = results[0].AsTensor <float>();
var detection_classes = results[1].AsTensor <float>();
var detection_scores = results[2].AsTensor <float>();
var num_detections = results[3].AsTensor <float>()[0];
using (var g = Graphics.FromImage(image))
{
for (int i = 0; i < num_detections; i++)
{
var score = detection_scores[0, i];
if (score > threshold)
{
var label = labels[(int)detection_classes[0, i] - 1];
var x = (int)(detection_boxes[0, i, 0] * height);
var y = (int)(detection_boxes[0, i, 1] * width);
var w = (int)(detection_boxes[0, i, 2] * height);
var h = (int)(detection_boxes[0, i, 3] * width);
// python rectangle
var rectangle = Rectangle.FromLTRB(y, x, h, w);
g.DrawString(label, font, new SolidBrush(c), y, x);
g.DrawRectangle(new Pen(c)
{
Width = 3
}, rectangle);
}
}
}
BackgroundImage = image;
Console.WriteLine("Drawing was finished in " + (Environment.TickCount - tic) + " mls.");
}
static void Main(string[] args)
{
// string is null or empty
if (args == null || args.Length < 3)
{
Console.WriteLine("Usage information: dotnet run model.onnx input.jpg output.jpg");
return;
}
else
{
if (!(File.Exists(args[0])))
{
Console.WriteLine("Model Path does not exist");
return;
}
if (!(File.Exists(args[1])))
{
Console.WriteLine("Input Path does not exist");
return;
}
}
// Read paths
string modelFilePath = args[0];
string imageFilePath = args[1];
string outImageFilePath = args[2];
using Image imageOrg = Image.Load(imageFilePath, out IImageFormat format);
//Letterbox image
var iw = imageOrg.Width;
var ih = imageOrg.Height;
var w = 416;
var h = 416;
if ((iw == 0) || (ih == 0))
{
Console.WriteLine("Math error: Attempted to divide by Zero");
return;
}
float width = (float)w / iw;
float height = (float)h / ih;
float scale = Math.Min(width, height);
var nw = (int)(iw * scale);
var nh = (int)(ih * scale);
var pad_dims_w = (w - nw) / 2;
var pad_dims_h = (h - nh) / 2;
// Resize image using default bicubic sampler
var image = imageOrg.Clone(x => x.Resize((nw), (nh)));
var clone = new Image <Rgb24>(w, h);
clone.Mutate(i => i.Fill(Color.Gray));
clone.Mutate(o => o.DrawImage(image, new Point(pad_dims_w, pad_dims_h), 1f)); // draw the first one top left
//Preprocessing image
Tensor <float> input = new DenseTensor <float>(new[] { 1, 3, h, w });
for (int y = 0; y < clone.Height; y++)
{
Span <Rgb24> pixelSpan = clone.GetPixelRowSpan(y);
for (int x = 0; x < clone.Width; x++)
{
input[0, 0, y, x] = pixelSpan[x].B / 255f;
input[0, 1, y, x] = pixelSpan[x].G / 255f;
input[0, 2, y, x] = pixelSpan[x].R / 255f;
}
}
//Get the Image Shape
var image_shape = new DenseTensor <float>(new[] { 1, 2 });
image_shape[0, 0] = ih;
image_shape[0, 1] = iw;
// Setup inputs and outputs
var container = new List <NamedOnnxValue>();
container.Add(NamedOnnxValue.CreateFromTensor("input_1", input));
container.Add(NamedOnnxValue.CreateFromTensor("image_shape", image_shape));
// Session Options
SessionOptions options = new SessionOptions();
options.LogSeverityLevel = OrtLoggingLevel.ORT_LOGGING_LEVEL_INFO;
options.AppendExecutionProvider_OpenVINO(@"MYRIAD_FP16");
options.AppendExecutionProvider_CPU(1);
// Run inference
using var session = new InferenceSession(modelFilePath, options);
using IDisposableReadOnlyCollection <DisposableNamedOnnxValue> results = session.Run(container);
Console.WriteLine("Inference done");
//Post Processing Steps
var resultsArray = results.ToArray();
Tensor <float> boxes = resultsArray[0].AsTensor <float>();
Tensor <float> scores = resultsArray[1].AsTensor <float>();
int[] indices = resultsArray[2].AsTensor <int>().ToArray();
var len = indices.Length / 3;
var out_classes = new int[len];
float[] out_scores = new float[len];
var predictions = new List <Prediction>();
var count = 0;
for (int i = 0; i < indices.Length; i = i + 3)
{
out_classes[count] = indices[i + 1];
out_scores[count] = scores[indices[i], indices[i + 1], indices[i + 2]];
predictions.Add(new Prediction
{
Box = new Box(boxes[indices[i], indices[i + 2], 1],
boxes[indices[i], indices[i + 2], 0],
boxes[indices[i], indices[i + 2], 3],
boxes[indices[i], indices[i + 2], 2]),
Class = LabelMap.Labels[out_classes[count]],
Score = out_scores[count]
});
count++;
}
// Put boxes, labels and confidence on image and save for viewing
using var outputImage = File.OpenWrite(outImageFilePath);
Font font = SystemFonts.CreateFont("Arial", 16);
foreach (var p in predictions)
{
imageOrg.Mutate(x =>
{
x.DrawLines(Color.Red, 2f, new PointF[] {
new PointF(p.Box.Xmin, p.Box.Ymin),
new PointF(p.Box.Xmax, p.Box.Ymin),
new PointF(p.Box.Xmax, p.Box.Ymin),
new PointF(p.Box.Xmax, p.Box.Ymax),
new PointF(p.Box.Xmax, p.Box.Ymax),
new PointF(p.Box.Xmin, p.Box.Ymax),
new PointF(p.Box.Xmin, p.Box.Ymax),
new PointF(p.Box.Xmin, p.Box.Ymin)
});
x.DrawText($"{p.Class}, {p.Score:0.00}", font, Color.White, new PointF(p.Box.Xmin, p.Box.Ymin));
});
}
imageOrg.Save(outputImage, format);
}
static void Main(string[] args)
{
if (args.Length < 2)
{
System.Console.WriteLine("Not enough arguments given, use input image output image");
return;
}
// when using CPU / MKLDNN provider uncomment the next line
// var options = new SessionOptions();
// when using CUDA/GPU Provider if not comment this line
var options = SessionOptions.MakeSessionOptionWithCudaProvider();
options.GraphOptimizationLevel = GraphOptimizationLevel.ORT_ENABLE_ALL;
options.InterOpNumThreads = 8;
options.IntraOpNumThreads = 8;
String onnxfile = "YOUR_MUT1NY_DETECTOR_MODEL.onnx";
InferenceSession session = null;
scales[0] = 32.0f;
scales[1] = 16.0f;
scales[2] = 8.0f;
anchorLevels[0, 0, 0] = 116.0f;
anchorLevels[0, 0, 1] = 90.0f;
anchorLevels[0, 1, 0] = 156.0f;
anchorLevels[0, 1, 1] = 198.0f;
anchorLevels[0, 2, 0] = 373.0f;
anchorLevels[0, 2, 1] = 326.0f;
anchorLevels[1, 0, 0] = 30.0f;
anchorLevels[1, 0, 1] = 61.0f;
anchorLevels[1, 1, 0] = 62.0f;
anchorLevels[1, 1, 1] = 45.0f;
anchorLevels[1, 2, 0] = 59.0f;
anchorLevels[1, 2, 1] = 119.0f;
anchorLevels[2, 0, 0] = 10.0f;
anchorLevels[2, 0, 1] = 13.0f;
anchorLevels[2, 1, 0] = 16.0f;
anchorLevels[2, 1, 1] = 30.0f;
anchorLevels[2, 2, 0] = 33.0f;
anchorLevels[2, 2, 1] = 23.0f;
String inputFilename = args[0];
String outputFilename = args[1];
try
{
session = new InferenceSession(onnxfile, options);
var inputMeta = session.InputMetadata;
int[] inputDim = new int[4];
float scaleFactor;
int offsetX, offsetY;
foreach (var name in inputMeta.Keys)
{
var dim = inputMeta[name].Dimensions;
for (int n = 0; n < dim.Length; n++)
{
inputDim[n] = dim[n];
}
}
Stopwatch totalSw;
Stopwatch processInSw;
Stopwatch processOutSw;
Stopwatch executeSw;
long totalTime = 0;
long totalProcessIn = 0;
long totalProcessOut = 0;
long totalExecute = 0;
for (int runs = 0; runs < (BENCHMARKMODE ? NUMRUNS : 1); runs++)
{
totalSw = Stopwatch.StartNew();
processInSw = Stopwatch.StartNew();
var testData = CreateInputTensorFromImage(inputFilename, inputDim, out scaleFactor, out offsetX, out offsetY);
processInSw.Stop();
var container = new List <NamedOnnxValue>();
foreach (var name in inputMeta.Keys)
{
var tensor = new DenseTensor <float>(testData, inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
executeSw = Stopwatch.StartNew();
using (var results = session.Run(container))
{
executeSw.Stop();
int numResults = results.Count;
int levelNr = 0;
ArrayList dets = new ArrayList();
processOutSw = Stopwatch.StartNew();
foreach (var r in results)
{
var resultTensor = r.AsTensor <float>();
var resultDimension = resultTensor.Dimensions;
var resultArray = resultTensor.ToArray();
ProcessOutput(levelNr, resultDimension, resultArray, dets);
levelNr++;
}
System.Console.WriteLine("# Dets = " + dets.Count);
processOutSw.Stop();
dets.Sort();
ArrayList finalRects = BuildFinalOutput(dets, 1.0f / scaleFactor, offsetX, offsetY);
System.Console.WriteLine("Final # detected Rects = " + finalRects.Count);
totalSw.Stop();
Console.WriteLine("Prepocessing took " + processInSw.ElapsedMilliseconds);
Console.WriteLine("Execution of DNN took " + executeSw.ElapsedMilliseconds);
Console.WriteLine("Postprocessing took " + processOutSw.ElapsedMilliseconds);
Console.WriteLine("Total processing took " + totalSw.ElapsedMilliseconds);
if (runs > WARMUPRUNS)
{
totalTime += totalSw.ElapsedMilliseconds;
totalExecute += executeSw.ElapsedMilliseconds;
totalProcessIn += processInSw.ElapsedMilliseconds;
totalProcessOut += processOutSw.ElapsedMilliseconds;
}
if (!BENCHMARKMODE)
{
WriteOutputDet(inputFilename, outputFilename, finalRects);
}
results.Dispose();
container.Clear();
}
}
float avgTotalTime = (float)totalTime / (float)(NUMRUNS - WARMUPRUNS);
float avgExecuteTime = (float)totalExecute / (float)(NUMRUNS - WARMUPRUNS);
float avgProcessInTime = (float)totalProcessIn / (float)(NUMRUNS - WARMUPRUNS);
float avgProcessOutTime = (float)totalProcessOut / (float)(NUMRUNS - WARMUPRUNS);
Console.WriteLine("Avg time of preprocess: " + avgProcessInTime);
Console.WriteLine("Avg time of xecution of DNN: " + avgExecuteTime);
Console.WriteLine("Avg time of postprocess: " + avgProcessOutTime);
Console.WriteLine("Avg time of total: " + avgTotalTime);
}
catch (Exception e)
{
System.Console.WriteLine("Could not load ONNX model, because " + e.ToString());
return;
}
System.Console.WriteLine("Done");
}
public void RecognizeImagesInQueue(string modelPath, CancellationToken token)
{
string imagePath;
while (filesQueue.TryDequeue(out imagePath))
{
Tensor <float> tensor = ImageReader.GetTensorFromImageFile(imagePath);
lock (lockObject)
{
if (cancelAllThreads)
{
return;
}
}
if (token.IsCancellationRequested)
{
return;
}
using (var session = new InferenceSession(modelPath))
{
var inputMeta = session.InputMetadata;
var inputs = new List <NamedOnnxValue>();
lock (lockObject)
{
if (cancelAllThreads)
{
return;
}
}
if (token.IsCancellationRequested)
{
return;
}
foreach (var name in inputMeta.Keys)
{
inputs.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
lock (lockObject)
{
if (cancelAllThreads)
{
return;
}
}
if (token.IsCancellationRequested)
{
return;
}
using (var results = session.Run(inputs))
{
foreach (var result in results)
{
var resultTensor = result.AsTensor <float>();
int recognizedDigit = TensorArgMax(resultTensor);
string resultString = imagePath + '\n' + recognizedDigit.ToString() + '\n';
//resultsQueue.Enqueue(resultString);
resultsCollection.TryAdd(resultString);
}
}
}
}
}
private void pictureBox1_MouseUp(object sender, MouseEventArgs e)
{
//当鼠标左键释放时
//开始处理图片进行推理
if (e.Button == MouseButtons.Left)
{
Bitmap digitTmp = (Bitmap)digitImage.Clone();//复制digitImage
//调整图片大小为Mnist模型可接收的大小：28×28
using (Graphics g = Graphics.FromImage(digitTmp))
{
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.DrawImage(digitTmp, 0, 0, MnistImageSize, MnistImageSize);
}
//将图片转为灰阶图，并将图片的像素信息保存在list中
float[] imageArray = new float[MnistImageSize * MnistImageSize];
for (int y = 0; y < MnistImageSize; y++)
{
for (int x = 0; x < MnistImageSize; x++)
{
var color = digitTmp.GetPixel(x, y);
var a = (float)(0.5 - (color.R + color.G + color.B) / (3.0 * 255));
imageArray[y * MnistImageSize + x] = a;
}
}
// 设置要加载的模型的路径，跟据需要改为你的模型名称
string modelPath = AppDomain.CurrentDomain.BaseDirectory + "mnist.onnx";
using (var session = new InferenceSession(modelPath))
{
var inputMeta = session.InputMetadata;
var container = new List <NamedOnnxValue>();
// 用Netron看到需要的输入类型是float32[1, 1, 28, 28]
// 第一维None表示可以传入多张图片进行推理
// 这里只使用一张图片，所以使用的输入数据尺寸为[1, 1, 28, 28]
var shape = new int[] { 1, 1, MnistImageSize, MnistImageSize };
var tensor = new DenseTensor <float>(imageArray, shape);
// 支持多个输入，对于mnist模型，只需要一个输入，输入的名称是input3
container.Add(NamedOnnxValue.CreateFromTensor <float>("Input3", tensor));
// 推理
var results = session.Run(container);
// 输出结果: Plus214_Output_0
IList <float> imageList = results.FirstOrDefault(item => item.Name == "Plus214_Output_0").AsTensor <float>().ToList();
// Query to check for highest probability digit
var maxIndex = imageList.IndexOf(imageList.Max());
// Display the results
label1.Text = maxIndex.ToString();
}
}
}
public Mat prepareData(List <NamedOnnxValue> container, InferenceSession session1)
{
var inputMeta = session1.InputMetadata;
Mat mat2 = null;
foreach (var name in inputMeta.Keys)
{
var data = InputDatas[name];
if (data.Data is InternalArray intar)
{
for (int i = 0; i < inputMeta[name].Dimensions.Length; i++)
{
if (inputMeta[name].Dimensions[i] == -1)
{
inputMeta[name].Dimensions[i] = intar.Shape[i];
}
}
inputData = intar.Data.Select(z => (float)z).ToArray();
var tensor = new DenseTensor <float>(inputData, inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
if (data.Data is Mat matOrig)
{
var mat = matOrig.Clone();
lastReadedMat = mat.Clone();
if (inputMeta[name].Dimensions[2] == -1 && inputMeta[name].Dimensions[3] == -1)
{
inputMeta[name].Dimensions[2] = mat.Height;
inputMeta[name].Dimensions[3] = mat.Width;
}
mat2 = mat.Clone();
mat.ConvertTo(mat, MatType.CV_32F);
object param = mat;
foreach (var pitem in data.Preprocessors)
{
param = pitem.Process(param);
if (pitem is ZeroImagePreprocessor && param is Mat mt2)
{
inputMeta[name].Dimensions[3] = mt2.Width;
inputMeta[name].Dimensions[2] = mt2.Height;
mt2.ConvertTo(mt2, MatType.CV_32F);
}
if (pitem is AspectResizePreprocessor asp && param is Mat mt)
{
if (asp.ForceH)
{
inputMeta[name].Dimensions[3] = mt.Width;
inputMeta[name].Dimensions[2] = mt.Height;
}
if (inputMeta[name].Dimensions[2] != -1 && inputMeta[name].Dimensions[3] == -1)//keep aspect required
{
inputMeta[name].Dimensions[3] = mt.Width;
}
}
}
inputData = param as float[];
var tensor = new DenseTensor <float>(param as float[], inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
if (data.Data is VideoCapture cap)
{
Mat mat = new Mat();
bool w = false;
try
{
if (FetchNextFrame)
{
cap.Read(mat);
lastReadedMat = mat.Clone();
}
else
{
mat = lastReadedMat.Clone();
}
w = true;
if (inputMeta[name].Dimensions[2] == -1)
{
inputMeta[name].Dimensions[2] = mat.Height;
inputMeta[name].Dimensions[3] = mat.Width;
}
// pictureBox1.Image = BitmapConverter.ToBitmap(mat);
mat2 = mat.Clone();
mat.ConvertTo(mat, MatType.CV_32F);
object param = mat;
foreach (var pitem in data.Preprocessors)
{
param = pitem.Process(param);
}
inputData = param as float[];
var tensor = new DenseTensor <float>(param as float[], inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
catch (Exception ex)
{
throw new PrepareDataException()
{
IsVideo = true, SourceMat = w ? lastReadedMat : null
};
}
}
if (data.Data is float[] fl)
{
var tensor = new DenseTensor <float>(fl, inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
}
return(mat2);
}
private void run()
{
Stopwatch sw = Stopwatch.StartNew();
var inputMeta = session1.InputMetadata;
var container = new List <NamedOnnxValue>();
Mat mat2 = null;
foreach (var name in inputMeta.Keys)
{
var data = InputDatas[name];
if (data.Data is Mat matOrig)
{
//var mat = matOrig.Clone(new Rect(shiftX, shiftY, 576, 288));
var mat = matOrig.Clone();
//mat = mat.Resize(new OpenCvSharp.Size(576, 288));
if (inputMeta[name].Dimensions[2] == -1)
{
inputMeta[name].Dimensions[2] = mat.Height;
inputMeta[name].Dimensions[3] = mat.Width;
}
mat2 = mat.Clone();
mat.ConvertTo(mat, MatType.CV_32F);
object param = mat;
foreach (var pitem in data.Preprocessors)
{
param = pitem.Process(param);
}
inputData = param as float[];
var tensor = new DenseTensor <float>(param as float[], inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
}
OutputDatas.Clear();
using (var results = session1.Run(container))
{
// Get the results
foreach (var result in results)
{
var data = result.AsTensor <float>();
//var dims = data.Dimensions;
var rets = data.ToArray();
OutputDatas.Add(result.Name, rets);
}
}
//if (checkBox1.Checked)
{
Stopwatch sw2 = Stopwatch.StartNew();
var ret = boxesDecode(mat2);
lock (lock1)
{
last = ret;
}
sw2.Stop();
if (ret != null)
{
//var mm = drawBoxes(mat2, ret.Item1, ret.Item2, visTresh, ret.Item3);
/*pictureBox1.Image = BitmapConverter.ToBitmap(mm);
* mat2 = mm;
* pictureBox1.Invoke((Action)(() =>
* {
* if (pictureBox1.Image != null)
* {
* pictureBox1.Image.Dispose();
* }
* pictureBox1.Image = BitmapConverter.ToBitmap(mm);
* }));*/
}
}
sw.Stop();
lastms = sw.ElapsedMilliseconds;
}
public List <string> DoOcr(string imageFilePath)
{
Mat rgbMat = new Mat();
int new_h, new_w;
Tensor <float> input = GetInputs(imageFilePath, rgbMat, out new_h, out new_w);
// Setup inputs and outputs
var inputs = new List <NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor("input0", input)
};
try
{
LineBoxDecode decode = new LineBoxDecode(rgbMat.Width, rgbMat.Height);
// Run inference modelFilePath
using (var session = new InferenceSession(modelFilePath))
{
using (IDisposableReadOnlyCollection <DisposableNamedOnnxValue> results = session.Run(inputs))
{
var resultsArray = results.ToArray();
decode.Do(resultsArray, new_w, new_h);
}
}
CnLinePrepare clp = new CnLinePrepare(rgbMat, decode.Boxes);
List <Tensor <float> > tensors = clp.GetTensors();
List <string> fresults = new List <string>();
using (var crnn = new CRNNHandle())
{
//crNNModelFilePath
using (var session = new InferenceSession(crNNModelFilePath))
{
foreach (Tensor <float> oneTensor in tensors)
{
fresults.Add(crnn.Run(session, oneTensor));
}
}
}
return(fresults);
/*
* the following code to draw box for each line of chinese
* foreach (List<Point> boxes in decode.Boxes.Values)
* {
* DrawBox(rgbMat, boxes);
* }
*
* CvInvoke.Imwrite(outImageFilePath, rgbMat);
*/
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ex.StackTrace);
}
return(null);
}
private void TestRegisterCustomOpLibrary()
{
using (var option = new SessionOptions())
{
string libName = "custom_op_library.dll";
string modelPath = "custom_op_test.onnx";
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
libName = "custom_op_library.dll";
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
libName = "libcustom_op_library.so";
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
libName = "libcustom_op_library.dylib";
}
string libFullPath = Path.Combine(Directory.GetCurrentDirectory(), libName);
Assert.True(File.Exists(libFullPath), $"Expected lib {libFullPath} does not exist.");
var ortEnvInstance = OrtEnv.Instance();
string[] providers = ortEnvInstance.GetAvailableProviders();
if (Array.Exists(providers, provider => provider == "CUDAExecutionProvider"))
{
option.AppendExecutionProvider_CUDA(0);
}
IntPtr libraryHandle = IntPtr.Zero;
try
{
option.RegisterCustomOpLibraryV2(libFullPath, out libraryHandle);
}
catch (Exception ex)
{
var msg = $"Failed to load custom op library {libFullPath}, error = {ex.Message}";
throw new Exception(msg + "\n" + ex.StackTrace);
}
using (var session = new InferenceSession(modelPath, option))
{
var inputContainer = new List <NamedOnnxValue>();
inputContainer.Add(NamedOnnxValue.CreateFromTensor <float>("input_1",
new DenseTensor <float>(
new float[]
{
1.1f, 2.2f, 3.3f, 4.4f, 5.5f,
6.6f, 7.7f, 8.8f, 9.9f, 10.0f,
11.1f, 12.2f, 13.3f, 14.4f, 15.5f
},
new int[] { 3, 5 }
)));
inputContainer.Add(NamedOnnxValue.CreateFromTensor <float>("input_2",
new DenseTensor <float>(
new float[]
{
15.5f, 14.4f, 13.3f, 12.2f, 11.1f,
10.0f, 9.9f, 8.8f, 7.7f, 6.6f,
5.5f, 4.4f, 3.3f, 2.2f, 1.1f
},
new int[] { 3, 5 }
)));
using (var result = session.Run(inputContainer))
{
Assert.Equal("output", result.First().Name);
var tensorOut = result.First().AsTensor <int>();
var expectedOut = new DenseTensor <int>(
new int[]
{
17, 17, 17, 17, 17,
17, 18, 18, 18, 17,
17, 17, 17, 17, 17
},
new int[] { 3, 5 }
);
Assert.True(tensorOut.SequenceEqual(expectedOut));
}
}
// Safe to unload the custom op shared library now
UnloadLibrary(libraryHandle);
}
}
public static string CaptionImageOnnx(ImageFile imageFile)
{
var image = Image.Load <Rgb24>(imageFile.FullPath, out IImageFormat format);
bool modifyImageFile = false;
if (!modifyImageFile)
{
image.Mutate(x =>
{
x.Resize(new ResizeOptions
{
Size = new Size(299, 299),
Mode = ResizeMode.Crop
});
});
}
else
{
using (Stream imageStream = new MemoryStream())
{
image.Mutate(x =>
{
x.Resize(new ResizeOptions
{
Size = new Size(299, 299),
Mode = ResizeMode.Crop
});
});
image.Save(imageStream, format);
};
}
Tensor <float> input = new DenseTensor <float>(new[] { 1, 3, 299, 299 });
var mean = new[] { 0.485f, 0.456f, 0.406f };
var stddev = new[] { 0.229f, 0.224f, 0.225f };
for (int y = 0; y < image.Height; y++)
{
Span <Rgb24> pixelSpan = image.GetPixelRowSpan(y);
for (int x = 0; x < image.Width; x++)
{
input[0, 0, y, x] = ((pixelSpan[x].R / 255f) - mean[0]) / stddev[0];
input[0, 1, y, x] = ((pixelSpan[x].G / 255f) - mean[1]) / stddev[1];
input[0, 2, y, x] = ((pixelSpan[x].B / 255f) - mean[2]) / stddev[2];
}
}
var inputs1 = new List <NamedOnnxValue>()
{
NamedOnnxValue.CreateFromTensor <float>("image", input)
};
var imgFtEx_session = new InferenceSession("C:\\Users\\jsell\\source\\repos\\FileSystemHelper\\ImageCaptionerPlugin\\Resources\\model\\ifem.onnx");
var encoder_session = new InferenceSession("C:\\Users\\jsell\\source\\repos\\FileSystemHelper\\ImageCaptionerPlugin\\Resources\\model\\encoder.onnx");
var decoder_session = new InferenceSession("C:\\Users\\jsell\\source\\repos\\FileSystemHelper\\ImageCaptionerPlugin\\Resources\\model\\decoder.onnx");
// image feature extraction layer
using (var outputs1 = imgFtEx_session.Run(inputs1))
{
var input2 = outputs1.First();
input2.Name = "imageFeatures";
var inputs2 = new List <NamedOnnxValue>()
{
input2
};
Console.WriteLine(outputs1.Count);
// encoder
using (var outputs2 = encoder_session.Run(inputs2))
{
// TODO
}
}
return("Caption");
}
static void Main(string[] args)
{
SessionOptions options = new SessionOptions();
options.GraphOptimizationLevel = GraphOptimizationLevel.ORT_ENABLE_EXTENDED;
using (var session = new InferenceSession(@"D:\Ubuntu\onnx_c#\project\TinyYolov3\TinyYolov3\Assets\yolov3-tiny.onnx", options))
{
var input = session.InputMetadata;
var output = session.OutputMetadata;
var container = new List <NamedOnnxValue>();
//var container = new List<NamedOnnxValue>();
float[] inputData0 = LoadTensorFromFile(@"D:\Ubuntu\onnx_c#\project\TinyYolov3\TinyYolov3\Assets\test_data_set_0\input_0.txt"); //image data
float[] inputData1 = LoadTensorFromFile(@"D:\Ubuntu\onnx_c#\project\TinyYolov3\TinyYolov3\Assets\test_data_set_0\input_1.txt"); //image shape
foreach (var name in input.Keys)
{
Console.WriteLine(name);
}
foreach (var name in output.Keys)
{
Console.WriteLine(name);
}
Console.WriteLine(input.Count);
Console.WriteLine(output.Count);
///// Create Inputs
var nov = new List <NamedOnnxValue>();
var tensor0 = new DenseTensor <float>(inputData0, new int[] { 1, 3, 416, 416 });
//var tensor1 = new DenseTensor<float>(new float[] { 375, 500 }, new int[] { 1, 2 });
var tensor1 = new DenseTensor <float>(inputData1, new int[] { 1, 2 });
container.Add(NamedOnnxValue.CreateFromTensor <float>("input_1", tensor0));
container.Add(NamedOnnxValue.CreateFromTensor <float>("image_shape", tensor1));
// Run the inference
using (var results = session.Run(container)) // results is an IDisposableReadOnlyCollection<DisposableNamedOnnxValue> container
{
// dump the results
foreach (var r in results)
{
//Console.WriteLine(r.Name);
//Console.WriteLine(r.AsTensor<int>().GetArrayString());
//Console.WriteLine(r.AsTensor<int>().GetArrayString());
if (r.Name == "yolonms_layer_1")
{
File.WriteAllText(@"D:\Ubuntu\onnx_c#\project\TinyYolov3\TinyYolov3\Assets\test_data_set_0\out_0.txt", r.AsTensor <float>().GetArrayString());
}
if (r.Name == "yolonms_layer_1:1")
{
File.WriteAllText(@"D:\Ubuntu\onnx_c#\project\TinyYolov3\TinyYolov3\Assets\test_data_set_0\out_1.txt", r.AsTensor <float>().GetArrayString());
}
if (r.Name == "yolonms_layer_1:2")
{
File.WriteAllText(@"D:\Ubuntu\onnx_c#\project\TinyYolov3\TinyYolov3\Assets\test_data_set_0\out_2.txt", r.AsTensor <int>().GetArrayString());
}
}
}
}
while (true)
{
}
}
public ImageRepresentation ProcessFile(ImageRepresentation Img)
{
byte[] ByteImage = Convert.FromBase64String(Img.Base64Image);
string hash = Hash.GetHash(ByteImage);
Img.ImageHash = hash;
using (var db = new LibraryContext())
{
bool found = false;
foreach (var img in db.Images)
{
if (Hash.VerifyHash(hash, img.ImageHash))
{
db.Entry(img).Reference(a => a.ByteImage).Load();
if (Hash.ByteArrayCompare(ByteImage, img.ByteImage.Img))
{
img.NumOfRequests += 1;
Img.ClassName = img.ClassName;
Img.Prob = img.Prob;
Img.ImageId = img.ImageInfoId;
Img.NumOfRequests = img.NumOfRequests;
found = true;
break;
}
}
}
if (found)
{
SaveDataBaseConcurrent(db, null);
return(Img);
}
}
using Image <Rgb24> image = Image.Load <Rgb24>(ByteImage);
const int TargetWidth = 28;
const int TargetHeight = 28;
// Resize image to the 28 x 28
image.Mutate(x =>
{
x.Resize(new ResizeOptions
{
Size = new Size(TargetWidth, TargetHeight),
Mode = ResizeMode.Crop
});
x.Grayscale();
});
// Create tensor of shape (batch-size, channels, height, width) and normalize the image
var input = new DenseTensor <float>(new[] { 1, 1, TargetHeight, TargetWidth });
for (int y = 0; y < TargetHeight; y++)
{
for (int x = 0; x < TargetWidth; x++)
{
input[0, 0, y, x] = image[x, y].R / 255f;
}
}
// Create the inputs to the model
var inputs = new List <NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor(inputnodename, input)
};
// Run NNet
using IDisposableReadOnlyCollection <DisposableNamedOnnxValue> results = session.Run(inputs);
// Softmax calculation
var output = results.First().AsEnumerable <float>().ToArray();
var sum = output.Sum(x => (float)Math.Exp(x));
var softmax = output.Select(x => (float)Math.Exp(x) / sum);
float maxValue = softmax.Max();
string maxClass = softmax.ToList().IndexOf(maxValue).ToString();
using (var db = new LibraryContext())
{
var NewImage = new ImageInfo()
{
ClassName = maxClass, Prob = maxValue, ImageName = Img.ImageName, NumOfRequests = 0, ImageHash = hash, ByteImage = new ImageFile {
Img = ByteImage
}
};
NewImage.ImageClasses = new List <ImageClass>();
var ClassNum = db.ImageClasses.Where(a => a.ClassName == maxClass).FirstOrDefault();
if (ClassNum != null)
{
NewImage.ImageClasses.Add(ClassNum);
ClassNum.Images = new List <ImageInfo>();
ClassNum.Images.Add(NewImage);
db.Add(NewImage);
}
else
{
var NewClass = new ImageClass()
{
ClassName = maxClass
};
NewImage.ImageClasses.Add(NewClass);
NewClass.Images = new List <ImageInfo>();
NewClass.Images.Add(NewImage);
db.Add(NewClass);
db.Add(NewImage);
}
db.SaveChanges();
}
Img.NumOfRequests = 0;
Img.ClassName = maxClass;
Img.Prob = maxValue;
return(Img);
}
void Add_File(List <NamedOnnxValue> inputs, int[] dimentions, string input_meta_key)
{
Tensor <float> t = LoadTensorFromFileBytes(b_data);
inputs.Add(NamedOnnxValue.CreateFromTensor <float>(input_meta_key, t));
}
static void Main()
{
var session = new InferenceSession(@"../../../Models/cntk-mlp15.onnx");
var session1 = new InferenceSession(@"../../../Models/tf-mlp20.onnx");
var inputMeta = session.InputMetadata;
//var outputMeta = session.OutputMetadata;
var input1Meta = session1.InputMetadata;
//var output1Meta = session1.OutputMetadata;
List <NamedOnnxValue> container = new List <NamedOnnxValue>();
int[] dm = new int[] { 1, 1000 };
//Previous runs with small amounts of data
//var Data = LoadTENSORSFromFiles(@"../../../Data/Test_Bitstring/");
//var Data = LoadTENSORSFromFiles(@"../../../Data/Test_Bitstring2/");
var Data = LoadTENSORSFromFiles(@"../../../Data/Evolved_Bitstring/Bitstrings/");
int x = 0;
foreach (var fltArrList in Data.Tensors)
{
foreach (var fltArr in fltArrList.Value)
{
float[] sourceData = fltArr;
string fileName = fltArrList.Key;
Utilities.DatabaseUtils insertData = new Utilities.DatabaseUtils();
int tinyIntID = insertData.InsertFloatsIntoEvolvedTinyInts(fileName, sourceData);
foreach (var name in inputMeta.Keys)
{
container.Clear();
var tensor = new Microsoft.ML.OnnxRuntime.Tensors.DenseTensor <float>(fltArr, dm);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
using (var results = session.Run(container)) // results is an IDisposableReadOnlyCollection<DisposableNamedOnnxValue> container
{
foreach (var r in results)
{
{
//Console.WriteLine("Output for {0}", r.Name);
StringBuilder s = new StringBuilder();
var str = r.AsTensor <float>().GetArrayString();
var str1 = str.Replace('{', ' ').Replace('}', ' ').Trim();
var flt = float.Parse(str1);
//if (flt*1000 > 4.0)
{
Console.WriteLine(x);
Console.WriteLine(Path.GetFileName(fileName));
Console.WriteLine(flt * 10000);
insertData.InsertOrUpdateEvolvedFilesMetaCNTK(tinyIntID, Path.GetFileName(fileName), flt * 10000);
}
x++;
}
}
}
foreach (var name1 in input1Meta.Keys)
{
container.Clear();
var tensor1 = new Microsoft.ML.OnnxRuntime.Tensors.DenseTensor <float>(fltArr, dm);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name1, tensor1));
using var results = session1.Run(container);
foreach (var r in results)
{
{
//Console.WriteLine("Output for {0}", r.Name);
StringBuilder s = new StringBuilder();
var str = r.AsTensor <float>().GetArrayString();
var str1 = str.Replace('{', ' ').Replace('}', ' ').Trim();
var flt = float.Parse(str1);
//if (flt*1000 > 4.0)
{
Console.WriteLine(x);
Console.WriteLine(Path.GetFileName(fileName));
Console.WriteLine(flt * 100);
insertData.InsertOrUpdateEvolvedFilesMetaTF(tinyIntID, Path.GetFileName(fileName), flt * 100);
}
x++;
}
}
}
}
}
}
static void Main(string[] args)
{
if (args.Length < 2)
{
System.Console.WriteLine("Not enough arguments given use FaceSegmentationCMD inputimage outputimage");
}
else
{
byte[] REDLABEL = { 0, 0, 0, 255, 0, 255, 255, 255, 128, 255, 0 };
byte[] GREENLABEL = { 0, 255, 0, 0, 255, 255, 0, 255, 128, 192, 128 };
byte[] BLUELABEL = { 0, 0, 255, 0, 255, 0, 255, 255, 128, 192, 128 };
var options = new SessionOptions();
options.SetSessionGraphOptimizationLevel(2);
var path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location);
String onnxfile = path + "\\facesegmentation_full_344.onnx";
InferenceSession session = null;
try
{
session = new InferenceSession(onnxfile, options);
} catch (Exception e)
{
System.Console.WriteLine("Could not load ONNX model, because " + e.ToString());
return;
}
try
{
var bitmap = new BitmapImage(new Uri(args[0]));
var bitmapWidth = bitmap.Width;
var bitmapHeight = bitmap.Height;
var inputMeta = session.InputMetadata;
var container = new List <NamedOnnxValue>();
int[] inputDim = new int[4];
double scaleFactor = 1.0;
foreach (var name in inputMeta.Keys)
{
var dim = inputMeta[name].Dimensions;
for (int n = 0; n < dim.Length; n++)
{
inputDim[n] = dim[n];
}
}
if (bitmapWidth > bitmapHeight)
{
scaleFactor = (double)inputDim[3] / bitmapWidth;
}
else
{
scaleFactor = (double)inputDim[2] / bitmapHeight;
}
TransformedBitmap tb = new TransformedBitmap(bitmap, new System.Windows.Media.ScaleTransform(scaleFactor, scaleFactor));
int newWidth = tb.PixelWidth;
int newHeight = tb.PixelHeight;
int channels = tb.Format.BitsPerPixel / 8;
int stride = channels * newWidth;
byte[] rawData = new byte[stride * newHeight];
byte[] rawLabelOutput = new byte[inputDim[2] * inputDim[3]];
byte[] rawOutput = new byte[stride * newHeight];
tb.CopyPixels(rawData, stride, 0);
int paddingX = inputDim[3] - newWidth;
int paddingY = inputDim[2] - newHeight;
float[] testData = new float[inputDim[2] * inputDim[3] * inputDim[1]];
// intialize the whole tensor data to background value so do not have to deal with padding later
for (int n = 0; n < inputDim[2] * inputDim[3] * inputDim[1]; n++)
{
testData[n] = -1.0f;
}
var offsetX = paddingX / 2;
var offsetY = paddingY / 2;
// fill up tensor with image data
for (int y = 0; y < newHeight; y++)
{
int y1 = y;
for (int x = 0; x < newWidth; x++)
{
testData[(x + offsetX) + (y + offsetY) * inputDim[3] + inputDim[2] * inputDim[3] * 2] = rawData[(x + y1 * newWidth) * channels] / 127.5f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3] + inputDim[2] * inputDim[3]] = rawData[(x + y1 * newWidth) * channels + 1] / 127.5f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3]] = rawData[(x + y1 * newWidth) * channels + 2] / 127.5f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3] + inputDim[2] * inputDim[3] * 2] -= 1.0f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3] + inputDim[2] * inputDim[3]] -= 1.0f;
testData[(x + offsetX) + (y + offsetY) * inputDim[3]] -= 1.0f;
}
}
foreach (var name in inputMeta.Keys)
{
var tensor = new DenseTensor <float>(testData, inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
using (var results = session.Run(container))
{
int numResults = results.Count;
foreach (var r in results)
{
System.Console.WriteLine(r.Name);
var resultTensor = r.AsTensor <float>();
var resultDimension = resultTensor.Dimensions;
System.Console.WriteLine(resultDimension.Length);
var resultArray = resultTensor.ToArray();
float[] pointVal = new float[resultDimension[1]];
for (var y = 0; y < resultDimension[2]; y++)
{
for (var x = 0; x < resultDimension[3]; x++)
{
for (var n = 0; n < resultDimension[1]; n++)
{
pointVal[n] = resultArray[x + y * resultDimension[3] + n * resultDimension[2] * resultDimension[3]];
}
Softmax(pointVal);
byte labelVal = (byte)MaxIndex(pointVal);
rawLabelOutput[x + y * resultDimension[3]] = labelVal;
}
}
if (resultDimension[1] < 64)
{
for (int y = 0; y < newHeight; y++)
{
for (int x = 0; x < newWidth; x++)
{
int n = rawLabelOutput[(x + offsetX) + (y + offsetY) * resultDimension[3]];
rawOutput[(x + y * newWidth) * channels + 3] = 255;
rawOutput[(x + y * newWidth) * channels + 2] = REDLABEL[n];
rawOutput[(x + y * newWidth) * channels + 1] = GREENLABEL[n];
rawOutput[(x + y * newWidth) * channels] = BLUELABEL[n];
}
}
}
else
{
for (int y = 0; y < newHeight; y++)
{
for (int x = 0; x < newWidth; x++)
{
int n = rawLabelOutput[(x + offsetX) + (y + offsetY) * resultDimension[3]];
rawOutput[(x + y * newWidth) * channels + 3] = 255;
rawOutput[(x + y * newWidth) * channels + 2] = (byte)n;
rawOutput[(x + y * newWidth) * channels + 1] = (byte)n;
rawOutput[(x + y * newWidth) * channels] = (byte)n;
}
}
}
var outputImage = ImageFromRawBgraArray(rawOutput, newWidth, newHeight, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
outputImage = ResizeImage(outputImage, (int)bitmapHeight, (int)bitmapWidth);
outputImage.Save(args[1]);
}
}
}
catch (Exception e)
{
System.Console.WriteLine("Could not load image because of " + e.ToString());
}
}
}
private void Correct(InferenceSession session, string path)
{
var rawImage = new BitmapImage();
while (true)
{
try
{
using (var stream = File.OpenRead(path))
{
rawImage.BeginInit();
rawImage.CacheOption = BitmapCacheOption.OnLoad;
rawImage.StreamSource = stream;
rawImage.EndInit();
}
}
catch (System.IO.IOException e)
{
var ret = WinForms.MessageBox.Show(
e.Message, "VRCPhotoRotationCorrector",
WinForms.MessageBoxButtons.RetryCancel);
if (ret == WinForms.DialogResult.Retry)
{
continue;
}
else
{
return;
}
}
break;
}
var scale = INPUT_SIZE / (double)Math.Max(rawImage.PixelWidth, rawImage.PixelHeight);
var scaledImage = new TransformedBitmap(rawImage, new ScaleTransform(scale, scale));
var data = new byte[INPUT_SIZE * INPUT_SIZE * 4];
var stride = INPUT_SIZE * 4;
var offsetX = (INPUT_SIZE - scaledImage.PixelWidth) / 2;
var offsetY = (INPUT_SIZE - scaledImage.PixelHeight) / 2;
scaledImage.CopyPixels(data, stride, offsetX * 4 + offsetY * stride);
var source = TransposeAndCast(data);
var dims = new int[] { 1, 3, INPUT_SIZE, INPUT_SIZE };
var probs = new float[4];
for (int rot = 0; rot < 4; ++rot)
{
if (rot != 0)
{
Rotate90(source);
}
var tensor = new DenseTensor <float>(source, dims);
var inputs = new List <NamedOnnxValue>()
{
NamedOnnxValue.CreateFromTensor <float>("input.1", tensor)
};
using (var results = session.Run(inputs))
{
foreach (var r in results)
{
var values = r.AsTensor <float>().ToArray();
var e0 = (float)Math.Exp(values[0]);
var e1 = (float)Math.Exp(values[1]);
probs[rot] = e0 / (e0 + e1);
}
}
}
var maxval = probs.Max();
if (probs[0] != maxval)
{
var angle = 0.0;
for (int a = 0; a < 4; ++a)
{
if (probs[a] == maxval)
{
angle = a * 90.0;
}
}
var rotatedImage = new TransformedBitmap(rawImage, new RotateTransform(angle));
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(rotatedImage));
var tmp = path + ".tmp.png";
using (var stream = File.OpenWrite(tmp))
{
encoder.Save(stream);
}
File.Delete(path);
File.Move(tmp, path);
}
// MessageBox.Show(path + ": " + probs[0].ToString() + ", " + probs[1].ToString() + ", " + probs[2].ToString() + ", " + probs[3].ToString());
}
public ImageInfo RecognizeImage(byte[] mas, string fileName)
{
var image = Image.Load <Rgb24>(mas);
const int TargetWidth = 224;
const int TargetHeight = 224;
// Изменяем размер картинки до 224 x 224
image.Mutate(x =>
{
x.Resize(new ResizeOptions
{
Size = new Size(TargetWidth, TargetHeight),
Mode = ResizeMode.Crop // Сохраняем пропорции обрезая лишнее
});
});
// Перевод пикселов в тензор и нормализация
var input = new DenseTensor <float>(new[] { 1, 3, TargetHeight, TargetWidth });
var mean = new[] { 0.485f, 0.456f, 0.406f };
var stddev = new[] { 0.229f, 0.224f, 0.225f };
for (int y = 0; y < TargetHeight; y++)
{
Span <Rgb24> pixelSpan = image.GetPixelRowSpan(y);
for (int x = 0; x < TargetWidth; x++)
{
input[0, 0, y, x] = ((pixelSpan[x].R / 255f) - mean[0]) / stddev[0];
input[0, 1, y, x] = ((pixelSpan[x].G / 255f) - mean[1]) / stddev[1];
input[0, 2, y, x] = ((pixelSpan[x].B / 255f) - mean[2]) / stddev[2];
}
}
// Подготавливаем входные данные нейросети. Имя input задано в файле модели
var inputs = new List <NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor("data", input)
};
// Вычисляем предсказание нейросетью
ImageInfo tmp = new ImageInfo();
var session = new InferenceSession(@"C:\Users\Маша\Documents\Visual Studio 2017\Projects\RecognizerLib\resnet18-v2-7.onnx");
//res = "Predicting contents of image...\n";
//Console.WriteLine("Predicting contents of image...");
IDisposableReadOnlyCollection <DisposableNamedOnnxValue> results = session.Run(inputs);
// Получаем 1000 выходов и считаем для них softmax
var output = results.First().AsEnumerable <float>().ToArray();
var sum = output.Sum(x => (float)Math.Exp(x));
var softmax = output.Select(x => (float)Math.Exp(x) / sum);
// Выдаем 10 наиболее вероятных результатов на экран
foreach (var p in softmax
.Select((x, g) => new { Label = classLabels[g], Confidence = x })
.OrderByDescending(x => x.Confidence)
.Take(10))
{
tmp.AddInfo(fileName, p.Label, p.Confidence);
}
return(tmp);
}
public void GetResults()
{
int numThreads = Environment.ProcessorCount;
int chunk = fullNames.Count() / numThreads + 1;
Thread[] threads = new Thread[numThreads];
for (int i = 0; i < numThreads; i++)
{
int chunkStart = i * chunk;
int chunkEnd = chunkStart + chunk < fullNames.Count() ? chunkStart + chunk : fullNames.Count();
threads[i] = new Thread(() =>
{
for (int j = chunkStart; j < chunkEnd; j++)
{
if (token.IsCancellationRequested)
{
//Console.WriteLine("Termination...");
cancelTokenSource.Dispose();
return;
//System.Environment.Exit(0);
}
var image = Image.Load <Rgb24>(fullNames[j]);
const int TargetWidth = 224;
const int TargetHeight = 224;
// Изменяем размер картинки до 224 x 224
image.Mutate(x =>
{
x.Resize(new ResizeOptions
{
Size = new Size(TargetWidth, TargetHeight),
Mode = ResizeMode.Crop // Сохраняем пропорции обрезая лишнее
});
});
// Перевод пикселов в тензор и нормализация
var input = new DenseTensor <float>(new[] { 1, 3, TargetHeight, TargetWidth });
var mean = new[] { 0.485f, 0.456f, 0.406f };
var stddev = new[] { 0.229f, 0.224f, 0.225f };
for (int y = 0; y < TargetHeight; y++)
{
Span <Rgb24> pixelSpan = image.GetPixelRowSpan(y);
for (int x = 0; x < TargetWidth; x++)
{
input[0, 0, y, x] = ((pixelSpan[x].R / 255f) - mean[0]) / stddev[0];
input[0, 1, y, x] = ((pixelSpan[x].G / 255f) - mean[1]) / stddev[1];
input[0, 2, y, x] = ((pixelSpan[x].B / 255f) - mean[2]) / stddev[2];
}
}
// Подготавливаем входные данные нейросети. Имя input задано в файле модели
var inputs = new List <NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor("data", input)
};
// Вычисляем предсказание нейросетью
waitHandler.WaitOne();
ImageInfo tmp = new ImageInfo();
var session = new InferenceSession(@"C:\Users\Маша\Documents\Visual Studio 2017\Projects\RecognizerLib\resnet18-v2-7.onnx");
//res = "Predicting contents of image...\n";
//Console.WriteLine("Predicting contents of image...");
IDisposableReadOnlyCollection <DisposableNamedOnnxValue> results = session.Run(inputs);
// Получаем 1000 выходов и считаем для них softmax
var output = results.First().AsEnumerable <float>().ToArray();
var sum = output.Sum(x => (float)Math.Exp(x));
var softmax = output.Select(x => (float)Math.Exp(x) / sum);
// Выдаем 10 наиболее вероятных результатов на экран
foreach (var p in softmax
.Select((x, g) => new { Label = classLabels[g], Confidence = x })
.OrderByDescending(x => x.Confidence)
.Take(10))
{
tmp.AddInfo(fullNames[j], p.Label, p.Confidence);
}
//res += p.Label + " with confidence " + p.Confidence + "\n";
//Console.WriteLine($"{p.Label} with confidence {p.Confidence}");
//Console.WriteLine("pic: " + j);
// Console.WriteLine(tmp);
//res += "\n";
//result.Add(tmp);
//if (iConsoleInterface != null)
// iConsoleInterface.ReturnRes(tmp);
ires.ReturnRes(tmp);
//Thread.Sleep(1000);
waitHandler.Set();
}
});
threads[i].Start();
}
foreach (Thread thread in threads)
{
thread.Join();
}
}
private void TestTensorRTProviderOptions()
{
string modelPath = Path.Combine(Directory.GetCurrentDirectory(), "squeezenet.onnx");
string calTablePath = "squeezenet_calibration.flatbuffers";
string enginePath = "./";
string engineDecrptLibPath = "engine_decryp";
using (var cleanUp = new DisposableListTest <IDisposable>())
{
var trtProviderOptions = new OrtTensorRTProviderOptions();
cleanUp.Add(trtProviderOptions);
var providerOptionsDict = new Dictionary <string, string>();
providerOptionsDict["device_id"] = "0";
providerOptionsDict["trt_fp16_enable"] = "1";
providerOptionsDict["trt_int8_enable"] = "1";
providerOptionsDict["trt_int8_calibration_table_name"] = calTablePath;
providerOptionsDict["trt_engine_cache_enable"] = "1";
providerOptionsDict["trt_engine_cache_path"] = enginePath;
providerOptionsDict["trt_engine_decryption_enable"] = "0";
providerOptionsDict["trt_engine_decryption_lib_path"] = engineDecrptLibPath;
trtProviderOptions.UpdateOptions(providerOptionsDict);
var resultProviderOptionsDict = new Dictionary <string, string>();
ProviderOptionsValueHelper.StringToDict(trtProviderOptions.GetOptions(), resultProviderOptionsDict);
// test provider options configuration
string value;
value = resultProviderOptionsDict["device_id"];
Assert.Equal("0", value);
value = resultProviderOptionsDict["trt_fp16_enable"];
Assert.Equal("1", value);
value = resultProviderOptionsDict["trt_int8_enable"];
Assert.Equal("1", value);
value = resultProviderOptionsDict["trt_int8_calibration_table_name"];
Assert.Equal(calTablePath, value);
value = resultProviderOptionsDict["trt_engine_cache_enable"];
Assert.Equal("1", value);
value = resultProviderOptionsDict["trt_engine_cache_path"];
Assert.Equal(enginePath, value);
value = resultProviderOptionsDict["trt_engine_decryption_enable"];
Assert.Equal("0", value);
value = resultProviderOptionsDict["trt_engine_decryption_lib_path"];
Assert.Equal(engineDecrptLibPath, value);
// test correctness of provider options
SessionOptions options = SessionOptions.MakeSessionOptionWithTensorrtProvider(trtProviderOptions);
cleanUp.Add(options);
var session = new InferenceSession(modelPath, options);
cleanUp.Add(session);
var inputMeta = session.InputMetadata;
var container = new List <NamedOnnxValue>();
float[] inputData = TestDataLoader.LoadTensorFromFile(@"bench.in"); // this is the data for only one input tensor for this model
foreach (var name in inputMeta.Keys)
{
Assert.Equal(typeof(float), inputMeta[name].ElementType);
Assert.True(inputMeta[name].IsTensor);
var tensor = new DenseTensor <float>(inputData, inputMeta[name].Dimensions);
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
session.Run(container);
}
}
static void Main(string[] args)
{
using var image = Image.Load <Rgb24>(args.FirstOrDefault() ?? "image.jpg");
const int TargetWidth = 224;
const int TargetHeight = 224;
// Изменяем размер картинки до 224 x 224
image.Mutate(x =>
{
x.Resize(new ResizeOptions
{
Size = new Size(TargetWidth, TargetHeight),
Mode = ResizeMode.Crop // Сохраняем пропорции обрезая лишнее
});
});
// Перевод пикселов в тензор и нормализация
var input = new DenseTensor <float>(new[] { 1, 3, TargetHeight, TargetWidth });
var mean = new[] { 0.485f, 0.456f, 0.406f };
var stddev = new[] { 0.229f, 0.224f, 0.225f };
for (int y = 0; y < TargetHeight; y++)
{
Span <Rgb24> pixelSpan = image.GetPixelRowSpan(y);
for (int x = 0; x < TargetWidth; x++)
{
input[0, 0, y, x] = ((pixelSpan[x].R / 255f) - mean[0]) / stddev[0];
input[0, 1, y, x] = ((pixelSpan[x].G / 255f) - mean[1]) / stddev[1];
input[0, 2, y, x] = ((pixelSpan[x].B / 255f) - mean[2]) / stddev[2];
}
}
// Подготавливаем входные данные нейросети. Имя input задано в файле модели
var inputs = new List <NamedOnnxValue>
{
NamedOnnxValue.CreateFromTensor("input", input)
};
// Загружаем модель из встроенного ресурса.
// См. <EmbeddedResource> в файле проекта
using var modelStream = typeof(Program).Assembly.GetManifestResourceStream("OnnxSample.shufflenet-v2-10.onnx");
using var memoryStream = new MemoryStream();
modelStream.CopyTo(memoryStream);
using var session = new InferenceSession(memoryStream.ToArray());
// Вычисляем предсказание нейросетью
Console.WriteLine("Predicting contents of image...");
using IDisposableReadOnlyCollection <DisposableNamedOnnxValue> results = session.Run(inputs);
// Получаем 1000 выходов и считаем для них softmax
var output = results.First().AsEnumerable <float>().ToArray();
var sum = output.Sum(x => (float)Math.Exp(x));
var softmax = output.Select(x => (float)Math.Exp(x) / sum);
// Выдаем 10 наиболее вероятных результатов на экран
foreach (var p in softmax
.Select((x, i) => new { Label = classLabels[i], Confidence = x })
.OrderByDescending(x => x.Confidence)
.Take(10))
{
Console.WriteLine($"{p.Label} with confidence {p.Confidence}");
}
}
private void TestPreTrainedModels(string opset, string modelName)
{
var modelsDir = GetTestModelsDir();
string onnxModelFileName = null;
var modelDir = new DirectoryInfo(Path.Combine(modelsDir, opset, modelName));
try
{
var onnxModelNames = modelDir.GetFiles("*.onnx");
bool validModelFound = false;
if (onnxModelNames.Length > 0)
{
// TODO remove file "._resnet34v2.onnx" from test set
for (int i = 0; i < onnxModelNames.Length; i++)
{
if (onnxModelNames[i].Name != "._resnet34v2.onnx")
{
onnxModelNames[0] = onnxModelNames[i];
validModelFound = true;
}
}
}
if (validModelFound)
{
onnxModelFileName = Path.Combine(modelDir.FullName, onnxModelNames[0].Name);
}
else
{
var modelNamesList = string.Join(",", onnxModelNames.Select(x => x.ToString()));
throw new Exception($"Opset {opset} Model {modelName}. Can't determine model file name. Found these :{modelNamesList}");
}
using (var session = new InferenceSession(onnxModelFileName))
{
var inMeta = session.InputMetadata;
string testDataDirNamePattern = "test_data*";
if (opset == "opset9" && modelName == "LSTM_Seq_lens_unpacked")
{
testDataDirNamePattern = "seq_lens*"; // discrepancy in data directory
}
foreach (var testDataDir in modelDir.EnumerateDirectories(testDataDirNamePattern))
{
var inputContainer = new List <NamedOnnxValue>();
var outputContainer = new List <NamedOnnxValue>();
foreach (var f in testDataDir.EnumerateFiles("input_*.pb"))
{
inputContainer.Add(TestDataLoader.LoadTensorFromFilePb(f.FullName, inMeta));
}
foreach (var f in testDataDir.EnumerateFiles("output_*.pb"))
{
outputContainer.Add(TestDataLoader.LoadTensorFromFilePb(f.FullName, session.OutputMetadata));
}
using (var resultCollection = session.Run(inputContainer))
{
foreach (var result in resultCollection)
{
Assert.True(session.OutputMetadata.ContainsKey(result.Name));
var outputMeta = session.OutputMetadata[result.Name];
NamedOnnxValue outputValue = null;
foreach (var o in outputContainer)
{
if (o.Name == result.Name)
{
outputValue = o;
break;
}
}
if (outputValue == null)
{
outputValue = outputContainer.First(); // in case the output data file does not contain the name
}
if (outputMeta.IsTensor)
{
if (outputMeta.ElementType == typeof(float))
{
Assert.Equal(result.AsTensor <float>(), outputValue.AsTensor <float>(), new FloatComparer());
}
else if (outputMeta.ElementType == typeof(double))
{
Assert.Equal(result.AsTensor <double>(), outputValue.AsTensor <double>(), new DoubleComparer());
}
else if (outputMeta.ElementType == typeof(int))
{
Assert.Equal(result.AsTensor <int>(), outputValue.AsTensor <int>(), new ExactComparer <int>());
}
else if (outputMeta.ElementType == typeof(uint))
{
Assert.Equal(result.AsTensor <uint>(), outputValue.AsTensor <uint>(), new ExactComparer <uint>());
}
else if (outputMeta.ElementType == typeof(short))
{
Assert.Equal(result.AsTensor <short>(), outputValue.AsTensor <short>(), new ExactComparer <short>());
}
else if (outputMeta.ElementType == typeof(ushort))
{
Assert.Equal(result.AsTensor <ushort>(), outputValue.AsTensor <ushort>(), new ExactComparer <ushort>());
}
else if (outputMeta.ElementType == typeof(long))
{
Assert.Equal(result.AsTensor <long>(), outputValue.AsTensor <long>(), new ExactComparer <long>());
}
else if (outputMeta.ElementType == typeof(ulong))
{
Assert.Equal(result.AsTensor <ulong>(), outputValue.AsTensor <ulong>(), new ExactComparer <ulong>());
}
else if (outputMeta.ElementType == typeof(byte))
{
Assert.Equal(result.AsTensor <byte>(), outputValue.AsTensor <byte>(), new ExactComparer <byte>());
}
else if (outputMeta.ElementType == typeof(bool))
{
Assert.Equal(result.AsTensor <bool>(), outputValue.AsTensor <bool>(), new ExactComparer <bool>());
}
else if (outputMeta.ElementType == typeof(Float16))
{
Assert.Equal(result.AsTensor <Float16>(), outputValue.AsTensor <Float16>(), new Float16Comparer {
tolerance = 2
});
}
else if (outputMeta.ElementType == typeof(BFloat16))
{
Assert.Equal(result.AsTensor <BFloat16>(), outputValue.AsTensor <BFloat16>(), new BFloat16Comparer {
tolerance = 2
});
}
else
{
Assert.True(false, $"{nameof(TestPreTrainedModels)} does not yet support output of type {outputMeta.ElementType}");
}
}
else
{
Assert.True(false, $"{nameof(TestPreTrainedModels)} cannot handle non-tensor outputs yet");
}
}
}
}
}
}
catch (Exception ex)
{
var msg = $"Opset {opset}, Model {modelName}: ModelFile = {onnxModelFileName} error = {ex.Message}";
if (ex.Message.Contains("ONNX Runtime only *guarantees* support for models stamped with official released onnx opset versions"))
{
// If the exception is thrown because the opset version of the test model is
// not supported by ONNXRuntime yet, then ignore the test and proceed.
// ORT allows commits from ONNX master and in such cases we do come across new opsets which are
// not supported in ORT yet. In order to force these tests to run set env var ALLOW_RELEASED_ONNX_OPSET_ONLY=0
output.WriteLine("Skipping the model test as the latest ONNX opset is not supported yet. Error Message: " + msg);
}
else
{
throw new Exception(msg + "\n" + ex.StackTrace);
}
}
}
private void TestPreTrainedModelsOpset7And8()
{
// 16-bit float not supported type in C#.
var skipModels = new[] {
"fp16_inception_v1",
"fp16_shufflenet",
"fp16_tiny_yolov2"
};
var opsets = new[] { "opset7", "opset8" };
var modelsDir = GetTestModelsDir();
foreach (var opset in opsets)
{
var modelRoot = new DirectoryInfo(Path.Combine(modelsDir, opset));
//var cwd = Directory.GetCurrentDirectory();
foreach (var modelDir in modelRoot.EnumerateDirectories())
{
String onnxModelFileName = null;
if (skipModels.Contains(modelDir.Name))
{
continue;
}
try
{
var onnxModelNames = modelDir.GetFiles("*.onnx");
if (onnxModelNames.Length > 1)
{
// TODO remove file "._resnet34v2.onnx" from test set
bool validModelFound = false;
for (int i = 0; i < onnxModelNames.Length; i++)
{
if (onnxModelNames[i].Name != "._resnet34v2.onnx")
{
onnxModelNames[0] = onnxModelNames[i];
validModelFound = true;
}
}
if (!validModelFound)
{
var modelNamesList = string.Join(",", onnxModelNames.Select(x => x.ToString()));
throw new Exception($"Opset {opset}: Model {modelDir}. Can't determine model file name. Found these :{modelNamesList}");
}
}
onnxModelFileName = Path.Combine(modelsDir, opset, modelDir.Name, onnxModelNames[0].Name);
using (var session = new InferenceSession(onnxModelFileName))
{
var inMeta = session.InputMetadata;
var innodepair = inMeta.First();
var innodename = innodepair.Key;
var innodedims = innodepair.Value.Dimensions;
for (int i = 0; i < innodedims.Length; i++)
{
if (innodedims[i] < 0)
{
innodedims[i] = -1 * innodedims[i];
}
}
var testRoot = new DirectoryInfo(Path.Combine(modelsDir, opset, modelDir.Name));
var testData = testRoot.EnumerateDirectories("test_data*").First();
var dataIn = LoadTensorFromFilePb(Path.Combine(modelsDir, opset, modelDir.Name, testData.ToString(), "input_0.pb"));
var dataOut = LoadTensorFromFilePb(Path.Combine(modelsDir, opset, modelDir.Name, testData.ToString(), "output_0.pb"));
var tensorIn = new DenseTensor <float>(dataIn, innodedims);
var nov = new List <NamedOnnxValue>();
nov.Add(NamedOnnxValue.CreateFromTensor <float>(innodename, tensorIn));
using (var resnov = session.Run(nov))
{
var res = resnov.ToArray()[0].AsTensor <float>().ToArray <float>();
Assert.Equal(res, dataOut, new floatComparer());
}
}
}
catch (Exception ex)
{
var msg = $"Opset {opset}: Model {modelDir}: ModelFile = {onnxModelFileName} error = {ex.Message}";
throw new Exception(msg);
}
} //model
} //opset
}
public ConcurrentQueue <Output> processDirAsync(string dir_path)
{
if (exception != null)
{
exception = new Exception("Model was incorrect");
return(null);
}
else
{
Debug.WriteLine("REC");
ConcurrentQueue <string> requests = new ConcurrentQueue <string>(); //спросить мб лучше конкурентную использовать, и без блокировок обойтись
cts = new CancellationTokenSource();
ConcurrentQueue <Output> returns = new ConcurrentQueue <Output>();
int proc = System.Environment.ProcessorCount;
try
{
DirectoryInfo dir = new DirectoryInfo(dir_path);
var files = dir.GetFiles();
Thread[] threads = new Thread[proc];
Thread wait_thread = new Thread(() =>
{
for (int i = 0; i < proc; i++)
{
threads[i].Join();
}
returns.Enqueue(null);
});
wait_thread.IsBackground = true;
foreach (var file in files)
{
requests.Enqueue(file.FullName);
}
for (int i = 0; i < proc; i++)
{
threads[i] = new Thread(() =>
#region scary lambda
{
string image_path;
byte[] blob = null;
while (requests.TryDequeue(out image_path))
{
try
{
blob = File.ReadAllBytes(image_path);
}
catch
{
Debug.WriteLine("Cannot read file " + image_path);
continue;
}
if (DbProvider.isExist(image_path) && DbProvider.compareBlob(image_path, blob))
{
Debug.WriteLine("ALREADY EXIST " + image_path);
var img = DbProvider.getImage(image_path);
returns.Enqueue(new Output(image_path, new KeyValuePair <string, float>(img.Class, img.Probability)));
continue;
}
if (cts.Token.IsCancellationRequested)
{
return;
}
var inputMeta = session.InputMetadata;
var container = new List <NamedOnnxValue>();
float[] inputData;
//inputdata!=blob
if ((inputData = CustomImage.parseImage(image_path, blob)) == null)
{
return;
}
if (cts.Token.IsCancellationRequested)
{
return;
}
foreach (var name in inputMeta.Keys)
{
var tensor = new DenseTensor <float>(inputData, inputMeta[name].Dimensions);
//Microsoft.ML.OnnxRuntime.Tensors.Tensor
container.Add(NamedOnnxValue.CreateFromTensor <float>(name, tensor));
}
if (cts.Token.IsCancellationRequested)
{
return;
}
using (var results = session.Run(container))
{
foreach (var r in results)
{
var list = new List <KeyValuePair <string, float> >();
int iter = 0;
foreach (var a in r.AsEnumerable <float>())
{
list.Add(new KeyValuePair <string, float>(answers[iter].ToString(), a));
iter++;
}
var smthg = (from pair in list
orderby pair.Value descending
select pair).Take(3);
var buf = new Output(image_path, smthg.ToArray());
returns.Enqueue(buf);
DbProvider.add(image_path, smthg.First().Key, smthg.First().Value, blob);
}
}
}
}
#endregion
);
threads[i].Start();
}
wait_thread.Start();
}
catch (Exception ex)
{
exception = ex;
}
return(returns);
}
}
