completed thesisHEADmaster

1 files changed, 885 insertions, 0 deletions

diff --git a/python/openvino/runtime/dla_benchmark/inputs_filling.cpp b/python/openvino/runtime/dla_benchmark/inputs_filling.cpp
new file mode 100644
index 0000000..0d20a14
--- /dev/null
+++ b/python/openvino/runtime/dla_benchmark/inputs_filling.cpp
@@ -0,0 +1,885 @@
+// Copyright (C) 2018-2023 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+// Description: This file implements all supported formats of filling input tensors with input data.
+//              Functions in this file has been based off/modified from OpenVINO's input filling algorithms,
+//              which would be a good place to start for future OpenVINO uplifts.
+//              Ref: [openvinotoolkit/openvino › samples/cpp/benchmark_app/input_fillings.cpp]
+
+#include "inputs_filling.hpp"
+
+#include <algorithm>
+#include <cstdlib>
+#include <memory>
+#include <functional>
+#include <limits>
+#include <tuple>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <opencv2/videoio.hpp>
+#include <samples/ocv_common.hpp>
+#include <samples/slog.hpp>
+#include "format_reader_ptr.h"
+#include "shared_tensor_allocator.hpp"
+#include "utils.hpp"
+
+/**
+ * @brief Struct to store info of an image read by the FormatReader::Reader class
+*/
+struct ReaderInfo {
+  std::shared_ptr<uint8_t> data;  // Image data
+  const size_t file_index;        // Index of the image in the file_paths vector
+  const size_t channels;          // Number of channels used by the reader to store the image
+
+  ReaderInfo(std::shared_ptr<uint8_t>& data, size_t file_index, size_t channels)
+      : data(data), file_index(file_index), channels(channels) {}
+};
+
+// Since the reader always expands the image being read into an rgb image.
+// The only way to tell that an image is in fact an rgb and not a grayscale
+// image, it to find if the values in channel 0 differ from channel 1 or 2.
+// Return true if this is a grayscale image or an rgb image than can safely
+// be considered a grayscale image since all channel values are the same.
+static bool IsGrayScaleImage(const ReaderInfo& reader_info, uint32_t image_size) {
+  const auto num_channels = reader_info.channels;
+  const auto& image_data = reader_info.data;
+  // Iterate through the image surface
+  for (size_t pid = 0; pid < image_size; pid++) {
+    // Iterate through the image channels
+    for (size_t ch = 1; ch < num_channels; ++ch) {
+      if (image_data.get()[pid * num_channels + ch] != image_data.get()[pid * num_channels]) return false;
+    }
+  }
+  return true;
+}
+
+template <typename T>
+using uniformDistribution = typename std::conditional<
+    std::is_floating_point<T>::value,
+    std::uniform_real_distribution<T>,
+    typename std::conditional<std::is_integral<T>::value, std::uniform_int_distribution<T>, void>::type>::type;
+
+/**
+ * @brief Fills a tensor with image data from input files
+ *
+ * Helper function to GetStaticTensors(), not used outside this file.
+ * Determines which image to use based of of input_id, batch_size, input_size, and request_id.
+ * Reads that data as uint8 and creates an input tensor of type T corresponding to input element type.
+ *
+ * @param files vector of file paths to the input images
+ * @param input_id image input id, ie image 1, image 2...
+ * @param batch_size batch size of the tensor
+ * @param input_size number of images to be used
+ * @param request_id infer request id
+ * @param input_info InputInfo struct corresponding to the input node of the tensor
+ * @param input_name name of the input
+ * @param bgr boolean indicating if input channels need to be reversed
+ * @param verbose prints extra logging information if true
+ * @return ov::Tensor containing the input data extracted from the image
+*/
+template <typename T>
+ov::Tensor CreateTensorFromImage(const std::vector<std::string>& files,
+                                 const size_t input_id,
+                                 const size_t batch_size,
+                                 const size_t input_size,
+                                 const size_t request_id,
+                                 const dla_benchmark::InputInfo& input_info,
+                                 const std::string& input_name,
+                                 const FormatReader::Reader::ResizeType resize_type,
+                                 const bool bgr = false,
+                                 const bool verbose = false) {
+  size_t tensor_size =
+      std::accumulate(input_info.data_shape.begin(), input_info.data_shape.end(), 1, std::multiplies<size_t>());
+  auto allocator = std::make_shared<SharedTensorAllocator>(tensor_size * sizeof(T));
+  auto data = reinterpret_cast<T*>(allocator->get_buffer());
+  /** Collect images data ptrs **/
+  std::vector<ReaderInfo> vreader;
+  vreader.reserve(batch_size);
+
+  size_t img_batch_size = 1;
+  if (!input_info.layout.empty() && ov::layout::has_batch(input_info.layout)) {
+    img_batch_size = batch_size;
+  } else {
+    slog::warn << input_name << ": layout does not contain batch dimension. Assuming batch 1 for this input"
+               << slog::endl;
+  }
+
+  for (size_t i = 0, input_idx = request_id * batch_size * input_size + input_id; i < img_batch_size; i++, input_idx += input_size) {
+    input_idx %= files.size();
+    FormatReader::ReaderPtr reader(files[input_idx].c_str());
+    if (input_idx <= MAX_COUT_WITHOUT_VERBOSE || verbose) {
+      slog::info << "Prepare image " << files[input_idx] << slog::endl;
+      if (!verbose && input_idx == MAX_COUT_WITHOUT_VERBOSE) {
+        slog::info << "Truncating list of input files. Run with --verbose for complete list." << slog::endl;
+      }
+    }
+    if (reader.get() == nullptr) {
+      slog::warn << "Image " << files[input_idx] << " cannot be read!" << slog::endl << slog::endl;
+      continue;
+    }
+
+    /** Getting image data **/
+    std::shared_ptr<uint8_t> image_data(reader->getData(input_info.GetWidth(), input_info.GetHeight(), resize_type));
+    if (image_data) {
+      // Store the number of channels used in storing the image in the reader
+      // If the image is grayscale, the reader would will still store it as a three
+      // channel image and therefore to read the image correctly we need to read the
+      // first channel value and then skip the next two.
+      const auto reader_channels = reader->size() / (reader->width() * reader->height());
+      vreader.emplace_back(image_data, input_idx, reader_channels);
+    }
+  }
+
+  /** Fill input tensor with image. First b channel, then g and r channels **/
+  const size_t num_channels = input_info.GetChannels();
+  const size_t width = input_info.GetWidth();
+  const size_t height = input_info.GetHeight();
+  const size_t batch = input_info.GetBatch();
+
+  const size_t image_size = width * height;  // Calculate the image size
+
+  // Lambda expression for calculating the pixel index in inputBlobData
+  const auto get_index = [=](size_t image_id, size_t pid, size_t ch) {
+    // Reverse the channel index if bgr is set to true
+    return image_id * image_size * num_channels + (bgr ? ch : (num_channels - ch - 1)) * image_size + pid;
+  };
+
+  // Lambda expression for calculating the channel (if bgr)
+  const auto get_channel = [=](size_t ch) {
+    return bgr ? ch : (num_channels - ch - 1);
+  };
+
+  /** Iterate over all input images **/
+  for (size_t image_id = 0; image_id < vreader.size(); ++image_id) {
+    const auto& reader_info = vreader.at(image_id);
+    // Error out of the graph has a single channel input and the image is not grayscale
+    if (num_channels == 1 && !IsGrayScaleImage(reader_info, image_size)) {
+      THROW_IE_EXCEPTION
+          << "Graph input is grayscale (has a single channel) and the following image is in RGB format:\n\t"
+          << files.at(reader_info.file_index);
+    }
+    const auto reader_channels = reader_info.channels;
+    /** Iterate over all pixel in image (b,g,r) **/
+    for (size_t pid = 0; pid < image_size; pid++) {
+      /** Iterate over all channels **/
+      for (size_t ch = 0; ch < num_channels; ++ch) {
+        // check if scale values are 0
+        if (input_info.scale_values[get_channel(ch)] == 0) {
+          throw ov::Exception("Cannot apply scale value of 0");
+        }
+        // Reader is created with the assumption that the number of channels is always the maximum
+        data[get_index(image_id, pid, ch)] = static_cast<T>(
+            (reader_info.data.get()[pid * reader_channels + ch] - input_info.mean_values[get_channel(ch)]) /
+            input_info.scale_values[get_channel(ch)]);
+      }
+    }
+  }
+
+  auto tensor = ov::Tensor(input_info.type, {batch, num_channels, height, width}, ov::Allocator(allocator));
+  return tensor;
+}
+
+/**
+ * @brief Fills a tensor with video data from input files
+ *
+ * Helper function to GetStaticTensors(), not used outside this file.
+ * Determines which image to use based of of input_id, batch_size, input_size, and request_id.
+ * Reads that and creates an input tensor of type T corresponding to input element type.
+ *
+ * @param file_paths vector of file paths to the input images
+ * @param input_id binary input id, ie video 1, video 2...
+ * @param batch_size batch size of the tensor
+ * @param input_size number of images to be used
+ * @param request_id infer request id
+ * @param input_info InputInfo struct corresponding to the input node of the tensor
+ * @param input_name name of the input
+ * @param bgr boolean indicating if input channels need to be reversed
+ * @param verbose prints extra logging information if true
+ * @return ov::Tensor containing the input data extracted from the video
+*/
+template <typename T>
+ov::Tensor CreateTensorFromVideo(const std::vector<std::string>& file_paths,
+                                 const size_t input_id,
+                                 const size_t batch_size,
+                                 const size_t input_size,
+                                 const size_t request_id,
+                                 const dla_benchmark::InputInfo& input_info,
+                                 const std::string& input_name,
+                                 const bool bgr = false,
+                                 const bool verbose = false) {
+  size_t tensor_size =
+      std::accumulate(input_info.data_shape.begin(), input_info.data_shape.end(), 1, std::multiplies<size_t>());
+  auto allocator = std::make_shared<SharedTensorAllocator>(tensor_size * sizeof(T));
+  auto data = reinterpret_cast<T*>(allocator->get_buffer());
+
+  const size_t input_idx = (request_id * input_size + input_id) % file_paths.size();
+
+  const size_t channels = input_info.GetChannels();
+  const size_t height = input_info.GetHeight();
+  const size_t width = input_info.GetWidth();
+  const size_t frame_count = input_info.GetDepth();
+  const size_t batch = input_info.GetBatch();
+
+  std::vector<cv::Mat> frames_to_write;
+  frames_to_write.reserve(batch_size * frame_count);
+  if (verbose) slog::info << "Prepare Video " << file_paths[input_idx] << slog::endl;
+
+  // Open Video
+  cv::VideoCapture cap(file_paths[input_idx]);
+  if (!cap.isOpened()) {
+    throw std::runtime_error("Video file " + file_paths[input_idx] + " cannot be read!");
+  }
+
+  // Get amount of frames in video and calculate a step to partition the video into clips
+  size_t video_frames = 0;
+  size_t step;
+  size_t cur_video_pos = 0;
+  cv::Mat calc_frame;
+
+  // Using while loop instead of cv::get() since cv::get() isn't guaranteed to return
+  // the correct amount of frames
+  while ((cap.read(calc_frame))) {
+    if (calc_frame.empty()) {
+      break;
+    }
+    video_frames++;
+  }
+
+  // Reopen the file at the starting position
+  cap.release();
+  cap.open(file_paths[input_idx].c_str());
+  if (!cap.isOpened()) {
+    throw std::runtime_error("Video file " + file_paths[input_idx] + " cannot be read!");
+  }
+
+  if (verbose) {
+    slog::info << "Video file " << file_paths[input_idx] << " contains " << video_frames << " readable frames."
+               << slog::endl;
+  }
+
+  // Calculate step to partition video into "batch_size" amount of clips
+  if (batch_size == 1) {
+    step = frame_count;
+  } else if (video_frames < frame_count) {
+    step = 1;
+  } else {
+    step = std::max((size_t)1, (video_frames - frame_count) / (batch_size - 1));
+  }
+
+  // Get frames
+  for (size_t clip_start = 0; clip_start < batch_size * step; clip_start += step) {
+    // Attempt to set position using OpenCV + Video Codec
+    bool success = cap.set(cv::CAP_PROP_POS_FRAMES, clip_start);
+
+    // Unsupported by codec, set manually
+    if (!success) {
+      if (cur_video_pos < clip_start) {
+        while (cur_video_pos != clip_start) {
+          cap.read(calc_frame);
+          cur_video_pos++;
+        }
+      } else if (cur_video_pos > clip_start) {
+        // Reopen the file at the starting position
+        cap.release();
+        cap.open(file_paths[input_idx].c_str());
+        if (!cap.isOpened()) {
+          throw std::runtime_error("Video file " + file_paths[input_idx] + " cannot be read!");
+        }
+        cur_video_pos = 0;
+        while (cur_video_pos != clip_start) {
+          cap.read(calc_frame);
+          cur_video_pos++;
+        }
+      }
+    }
+
+    for (size_t curr_frame = 0; curr_frame < frame_count; curr_frame++) {
+      cv::Mat frame;
+      cap.read(frame);
+
+      // Frame is empty -> Clip is shorter than frame_count, loop from start of clip
+      if (frame.empty()) {
+        if (verbose)
+          slog::info << "A video clip was shorter than the desired frame count, looping video." << slog::endl;
+        bool success = cap.set(cv::CAP_PROP_POS_FRAMES, clip_start);
+
+        // If unsupported by codec, set manually
+        if (!success) {
+          // Reopen the file at the starting position
+          cap.release();
+          cap.open(file_paths[input_idx].c_str());
+          if (!cap.isOpened()) {
+            throw std::runtime_error("Video file " + file_paths[input_idx] + " cannot be read!");
+          }
+          cur_video_pos = 0;
+          while (cur_video_pos != clip_start) {
+            cap.read(calc_frame);
+            cur_video_pos++;
+          }
+        } else {
+          cur_video_pos = clip_start;
+        }
+
+        cap.read(frame);
+
+        // If it's still empty, then there's an error with reading
+        if (frame.empty()) {
+          slog::err << "Video file " << file_paths[input_idx] << " frames cannot be read!" << slog::endl << slog::endl;
+          continue;
+        }
+      }
+
+      cur_video_pos++;
+      // If bgr=false, convert to RGB
+      if (!bgr) {
+        cv::cvtColor(frame, frame, cv::COLOR_BGR2RGB);
+      }
+
+      // Check frame sizing, resize if it doesn't match expected blob size
+      cv::Mat resized_frame(frame);
+      if (static_cast<int>(width) != frame.size().width || static_cast<int>(height) != frame.size().height) {
+        // Resizes to 256 and centre crops based on actual needed dimensions, may add a flag for this in the future
+        // to be cleaner
+        if (static_cast<int>(width) < 256 && static_cast<int>(height) < 256) {
+          double scale;
+          if (frame.size().width <= frame.size().height)
+            scale = double(256) / frame.size().width;
+          else
+            scale = double(256) / frame.size().height;
+          cv::resize(frame, resized_frame, cv::Size(0, 0), scale, scale);
+          const int offsetW = (resized_frame.size().width - static_cast<int>(width)) / 2;
+          const int offsetH = (resized_frame.size().height - static_cast<int>(height)) / 2;
+          const cv::Rect roi(offsetW, offsetH, static_cast<int>(width), static_cast<int>(height));
+          resized_frame = resized_frame(roi).clone();
+        } else {
+          cv::resize(frame, resized_frame, cv::Size(width, height));
+        }
+      }
+      // Save frame to write
+      frames_to_write.emplace_back(resized_frame);
+    }
+  }
+
+  // Write frames to blob
+  for (size_t b = 0; b < batch_size; b++) {
+    size_t batch_offset = b * channels * frame_count * height * width;
+    for (size_t c = 0; c < channels; c++) {
+      size_t channel_offset = c * frame_count * height * width;
+      for (size_t frameId = b * frame_count; frameId < (b + 1) * frame_count; frameId++) {
+        const cv::Mat& frame_to_write = frames_to_write.at(frameId);
+        size_t frame_offset_id = frameId % frame_count;
+        size_t frame_offset = frame_offset_id * height * width;
+        for (size_t h = 0; h < height; h++) {
+          for (size_t w = 0; w < width; w++) {
+            data[batch_offset + channel_offset + frame_offset + h * width + w] = frame_to_write.at<cv::Vec3b>(h, w)[c];
+          }
+        }
+      }
+    }
+  }
+  cap.release();
+  return ov::Tensor(input_info.type, {batch, channels, frame_count, height, width}, ov::Allocator(allocator));
+}
+
+/**
+ * @brief Fills a tensor with image info data
+ *
+ * Helper function to GetStaticTensors(), not used outside this file.
+ *
+ * @param image_size Size of image width x height
+ * @param batch_size batch size of the tensor
+ * @param input_info InputInfo struct corresponding to the input node of the tensor
+ * @param input_name name of the input
+ * @return ov::Tensor containing the input data
+*/
+template <typename T>
+ov::Tensor CreateTensorImInfo(const std::pair<size_t, size_t>& image_size,
+                              size_t batch_size,
+                              const dla_benchmark::InputInfo& input_info,
+                              const std::string& input_name) {
+  size_t tensor_size =
+      std::accumulate(input_info.data_shape.begin(), input_info.data_shape.end(), 1, std::multiplies<size_t>());
+  auto allocator = std::make_shared<SharedTensorAllocator>(tensor_size * sizeof(T));
+  auto data = reinterpret_cast<T*>(allocator->get_buffer());
+
+  size_t info_batch_size = 1;
+  if (!input_info.layout.empty() && ov::layout::has_batch(input_info.layout)) {
+    info_batch_size = batch_size;
+  } else {
+    slog::warn << input_name << ": layout is not set or does not contain batch dimension. Assuming batch 1. "
+               << slog::endl;
+  }
+
+  for (size_t b = 0; b < info_batch_size; b++) {
+    size_t im_info_size = tensor_size / info_batch_size;
+    for (size_t i = 0; i < im_info_size; i++) {
+      size_t index = b * im_info_size + i;
+      if (0 == i)
+        data[index] = static_cast<T>(image_size.first);
+      else if (1 == i)
+        data[index] = static_cast<T>(image_size.second);
+      else
+        data[index] = 1;
+    }
+  }
+
+  auto tensor = ov::Tensor(input_info.type, input_info.data_shape, ov::Allocator(allocator));
+  return tensor;
+}
+
+/**
+ * @brief Fills a tensor with binary data from input files
+ *
+ * Helper function to GetStaticTensors(), not used outside this file.
+ * Determines which image to use based of of input_id, batch_size, input_size, and request_id.
+ * Reads that and creates an input tensor of type T corresponding to input element type.
+ *
+ * @param files vector of file paths to the input images
+ * @param input_id binary input id, ie binary 1, binary 2...
+ * @param batch_size batch size of the tensor
+ * @param input_size number of images to be used
+ * @param request_id infer request id
+ * @param input_info InputInfo struct corresponding to the input node of the tensor
+ * @param input_name name of the input
+ * @param verbose prints extra logging information if true
+ * @return ov::Tensor containing the input data extracted from the binary
+*/
+template <typename T>
+ov::Tensor CreateTensorFromBinary(const std::vector<std::string>& files,
+                                  const size_t input_id,
+                                  const size_t batch_size,
+                                  const size_t input_size,
+                                  const size_t request_id,
+                                  const dla_benchmark::InputInfo& input_info,
+                                  const std::string& input_name,
+                                  const bool verbose = false) {
+  size_t tensor_size =
+      std::accumulate(input_info.data_shape.begin(), input_info.data_shape.end(), 1, std::multiplies<size_t>());
+  auto allocator = std::make_shared<SharedTensorAllocator>(tensor_size * sizeof(T));
+  char* data = allocator->get_buffer();
+  size_t binary_batch_size = 1;
+  if (!input_info.layout.empty() && ov::layout::has_batch(input_info.layout)) {
+    binary_batch_size = batch_size;
+  } else {
+    slog::warn << input_name
+               << ": layout is not set or does not contain batch dimension. Assuming that binary "
+                  "data read from file contains data for all batches."
+               << slog::endl;
+  }
+
+  for (size_t b = 0, input_idx = request_id * batch_size * input_size + input_id; b < binary_batch_size; b++, input_idx += input_size) {
+    input_idx %= files.size();
+    if (input_idx <= MAX_COUT_WITHOUT_VERBOSE || verbose) {
+      slog::info << "Prepare binary file " << files[input_idx] << slog::endl;
+      if (!verbose && input_idx == MAX_COUT_WITHOUT_VERBOSE) {
+        slog::info << "Truncating list of input files. Run with --verbose for complete list." << slog::endl;
+      }
+    }
+    std::ifstream binary_file(files[input_idx], std::ios_base::binary | std::ios_base::ate);
+    OPENVINO_ASSERT(binary_file, "Cannot open ", files[input_idx]);
+
+    auto file_size = static_cast<std::size_t>(binary_file.tellg());
+    binary_file.seekg(0, std::ios_base::beg);
+    OPENVINO_ASSERT(binary_file.good(), "Can not read ", files[input_idx]);
+    auto input_size = tensor_size * sizeof(T) / binary_batch_size;
+    OPENVINO_ASSERT(file_size == input_size,
+                    "File ",
+                    files[input_idx],
+                    " contains ",
+                    file_size,
+                    " bytes, but the model expects ",
+                    input_size);
+
+    if (input_info.layout != "CN") {
+      binary_file.read(&data[b * input_size], input_size);
+    } else {
+      for (size_t i = 0; i < input_info.GetChannels(); i++) {
+        binary_file.read(&data[(i * binary_batch_size + b) * sizeof(T)], sizeof(T));
+      }
+    }
+  }
+
+  auto tensor = ov::Tensor(input_info.type, input_info.data_shape, ov::Allocator(allocator));
+  return tensor;
+}
+
+/**
+ * @brief Randomly fills input tensor, used when no input files is provided
+ *
+ * Helper function to GetStaticTensors(), not used outside this file.
+ *
+ * @param input_info InputInfo struct corresponding to the input node of the tensor
+ * @param rand_min Min. random value
+ * @param rand_max Max. random value
+ * @return ov::Tensor containing the the randomly generated input data
+*/
+template <typename T, typename T2>
+ov::Tensor CreateTensorRandom(const dla_benchmark::InputInfo& input_info,
+                              T rand_min = std::numeric_limits<uint8_t>::min(),
+                              T rand_max = std::numeric_limits<uint8_t>::max()) {
+  size_t tensor_size =
+      std::accumulate(input_info.data_shape.begin(), input_info.data_shape.end(), 1, std::multiplies<size_t>());
+  auto allocator = std::make_shared<SharedTensorAllocator>(tensor_size * sizeof(T));
+  auto data = reinterpret_cast<T*>(allocator->get_buffer());
+
+  std::mt19937 gen(0);
+  uniformDistribution<T2> distribution(rand_min, rand_max);
+  for (size_t i = 0; i < tensor_size; i++) {
+    data[i] = static_cast<T>(i%255);
+  }
+
+  ov::Shape tensor_shape = input_info.data_shape;
+  // FPGA model only supports channel first.
+  // The transpose for case NHWC and HWC below is ok since the tensor has randomly generated input data.
+  if (input_info.layout == "NHWC") {
+    // Use NCHW instead of NHWC since FPGA model only supports channel first.
+    tensor_shape = {input_info.GetBatch(), input_info.GetChannels(),
+                    input_info.GetHeight(), input_info.GetWidth()};
+  } else if (input_info.layout == "HWC") {
+    // Use CHW instead of HWC since FPGA model only supports channel first.
+    tensor_shape = {input_info.GetChannels(), input_info.GetHeight(), input_info.GetWidth()};
+  }
+
+  auto tensor = ov::Tensor(input_info.type, tensor_shape, ov::Allocator(allocator));
+  return tensor;
+}
+
+/**
+ * @brief Wrapper for CreateImageTensorFromImage, uses approriate stl data type for precision
+ *
+ * See CreateImageTensorFromImage for params. Helper for GetStaticTensors, not used outside this file.
+*/
+ov::Tensor GetImageTensor(const std::vector<std::string>& files,
+                          const size_t input_id,
+                          const size_t batch_size,
+                          const size_t input_size,
+                          const size_t request_id,
+                          const std::pair<std::string, dla_benchmark::InputInfo>& input_info,
+                          const FormatReader::Reader::ResizeType resize_type,
+                          const bool bgr = false,
+                          const bool verbose = false) {
+  // Edwinzha: All image data will be read as U8 but saved as a float in tensor data structure.
+  // Saving as U8 results in accuracy loss in diff check, especially in mobilenet graphs.
+  const ov::element::Type_t type = input_info.second.type;
+  if (type == ov::element::f16) {
+    return CreateTensorFromImage<ov::float16>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, resize_type, bgr, verbose);
+  } else  {
+    return CreateTensorFromImage<float>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, resize_type, bgr, verbose);
+  }
+}
+
+/**
+ * @brief Wrapper for CreateTensorFromVideo, uses appropriate stl data type for precision
+ *
+ * See CreateTensorFromVideo for params. Helper for GetStaticTensors, not used outside this file.
+*/
+ov::Tensor GetVideoTensor(const std::vector<std::string>& files,
+                          const size_t input_id,
+                          const size_t batch_size,
+                          const size_t input_size,
+                          const size_t request_id,
+                          const std::pair<std::string, dla_benchmark::InputInfo>& input_info,
+                          const bool bgr = false,
+                          const bool verbose = false) {
+  auto type = input_info.second.type;
+  if (type == ov::element::f32) {
+    return CreateTensorFromVideo<float>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, bgr, verbose);
+  } else if (type == ov::element::u8) {
+    return CreateTensorFromVideo<uint8_t>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, bgr, verbose);
+  } else if (type == ov::element::i32) {
+    return CreateTensorFromVideo<int32_t>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, bgr, verbose);
+  } else if (type == ov::element::f16) {
+    return CreateTensorFromVideo<ov::float16>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, bgr, verbose);
+  } else {
+    throw ov::Exception("Video input tensor type is not supported: " + input_info.first);
+  }
+}
+
+/**
+ * @brief Wrapper for CreateTensorRandom, uses appropriate stl data type for precision
+ *
+ * See CreateTensorRandom for params. Helper for GetStaticTensors, not used outside this file.
+*/
+ov::Tensor GetRandomTensor(const std::pair<std::string, dla_benchmark::InputInfo>& input_info) {
+  auto type = input_info.second.type;
+  if (type == ov::element::f32) {
+    return CreateTensorRandom<float, float>(input_info.second);
+  } else if (type == ov::element::f16) {
+    return CreateTensorRandom<short, short>(input_info.second);
+  } else if (type == ov::element::i32) {
+    return CreateTensorRandom<int32_t, int32_t>(input_info.second);
+  } else if (type == ov::element::u8) {
+    // uniform_int_distribution<uint8_t> is not allowed in the C++17
+    // standard and vs2017/19
+    return CreateTensorRandom<uint8_t, uint32_t>(input_info.second);
+  } else if (type == ov::element::i8) {
+    // uniform_int_distribution<int8_t> is not allowed in the C++17 standard
+    // and vs2017/19
+    return CreateTensorRandom<int8_t, int32_t>(
+        input_info.second, std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max());
+  } else if (type == ov::element::u16) {
+    return CreateTensorRandom<uint16_t, uint16_t>(input_info.second);
+  } else if (type == ov::element::i16) {
+    return CreateTensorRandom<int16_t, int16_t>(input_info.second);
+  } else {
+    throw ov::Exception("Random input tensor type is not supported: " + input_info.first);
+  }
+}
+
+/**
+ * @brief Wrapper for CreateTensorImInfo, uses appropriate stl data type for precision
+ *
+ * See CreateTensorImInfo for params. Helper for GetStaticTensors, not used outside this file.
+*/
+ov::Tensor GetImInfoTensor(const std::pair<size_t, size_t>& image_size,
+                           size_t batch_size,
+                           const std::pair<std::string, dla_benchmark::InputInfo>& input_info) {
+  auto type = input_info.second.type;
+  if (type == ov::element::f32) {
+    return CreateTensorImInfo<float>(image_size, batch_size, input_info.second, input_info.first);
+  } else if (type == ov::element::f64) {
+    return CreateTensorImInfo<double>(image_size, batch_size, input_info.second, input_info.first);
+  } else if (type == ov::element::f16) {
+    return CreateTensorImInfo<ov::float16>(image_size, batch_size, input_info.second, input_info.first);
+  } else if (type == ov::element::i32) {
+    return CreateTensorImInfo<int32_t>(image_size, batch_size, input_info.second, input_info.first);
+  } else if (type == ov::element::i64) {
+    return CreateTensorImInfo<int64_t>(image_size, batch_size, input_info.second, input_info.first);
+  } else {
+    throw ov::Exception("Image info input tensor type is not supported:" + input_info.first);
+  }
+}
+
+/**
+ * @brief Wrapper for GetBinaryTensor, uses appropriate stl data type for precision
+ *
+ * See GetBinaryTensor for params. Helper for GetStaticTensors, not used outside this file.
+*/
+ov::Tensor GetBinaryTensor(const std::vector<std::string>& files,
+                           const size_t input_id,
+                           const size_t batch_size,
+                           const size_t input_size,
+                           const size_t request_id,
+                           const std::pair<std::string, dla_benchmark::InputInfo>& input_info,
+                           const bool verbose = false) {
+  const auto& type = input_info.second.type;
+  if (type == ov::element::f32) {
+    return CreateTensorFromBinary<float>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, verbose);
+  } else if (type == ov::element::f16) {
+    return CreateTensorFromBinary<ov::float16>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, verbose);
+  } else if (type == ov::element::i32) {
+    return CreateTensorFromBinary<int32_t>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, verbose);
+  } else if ((type == ov::element::u8)) {
+    return CreateTensorFromBinary<uint8_t>(
+        files, input_id, batch_size, input_size, request_id, input_info.second, input_info.first, verbose);
+  } else {
+    throw ov::Exception("Binary input tensor type is not supported: " + input_info.first);
+  }
+}
+
+/**
+ * @brief Main function used by DLA benchmark, creates input tensors based off of input files and precision
+ *
+ * Only creates static tensors (no dims of -1). Calls all other functions in this file.
+ *
+ * @param input_files vector of input file paths
+ * @param batch_size batch size of input
+ * @param inputs_info map of input name to InputInfo struct which contains useful input information
+ *                    such as precision, tensor layout
+ * @param requests_num number of infer requests
+ * @param bgr boolean indicating if channels are reversed, corresponds to user bgr flag
+ * @param is_binary_data boolean indicating if the image data should be binary, corresponding to user binary flag
+ * @param verbose Verbosity boolean. If true, additional logs are printed
+ * @return A map of input name with tensor vectors. TensorVector being an alias of ov::Tensors where
+ *         each index corresponds to the batch
+*/
+std::map<std::string, ov::TensorVector> GetStaticTensors(const std::vector<std::string>& input_files,
+                                                         const size_t& batch_size,
+                                                         dla_benchmark::InputsInfo& inputs_info,
+                                                         size_t requests_num,
+                                                         std::string resize_type,
+                                                         bool bgr = false,
+                                                         bool is_binary_data = false,
+                                                         bool verbose = false) {
+  std::map<std::string, ov::TensorVector> blobs;
+  std::vector<std::pair<size_t, size_t>> net_input_im_sizes;
+  std::vector<std::tuple<size_t, size_t, size_t>> net_input_vid_sizes;
+  FormatReader::Reader::ResizeType resize_type_enum;
+
+  if (resize_type == "resize") {
+    resize_type_enum = FormatReader::Reader::ResizeType::RESIZE;
+  } else if (resize_type == "pad_resize") {
+    resize_type_enum = FormatReader::Reader::ResizeType::PAD_RESIZE;
+  } else {
+    slog::err << resize_type << " is not a valid -resize_type option" << slog::endl;
+    exit(1);
+  }
+
+  for (auto& item : inputs_info) {
+    const std::string& name = item.first;
+    const auto& input_info = item.second;
+    if (input_info.IsImage() && !is_binary_data) {
+      net_input_im_sizes.emplace_back(input_info.GetWidth(), input_info.GetHeight());
+    } else if (input_info.IsVideo()) {
+      net_input_vid_sizes.emplace_back(input_info.GetDepth(), input_info.GetWidth(), input_info.GetHeight());
+    }
+    slog::info << "Network input '" << name << "' precision " << input_info.type << ", dimensions "
+               << input_info.layout.to_string() << ": ";
+    slog::info << "[";
+    for (size_t i = 0; i < input_info.data_shape.size(); ++i) {
+      slog::info << input_info.data_shape[i];
+      if (i < input_info.data_shape.size() - 1) {
+        slog::info << " ";
+      }
+    }
+    slog::info << "]" << slog::endl;
+  }
+
+  size_t img_input_count = net_input_im_sizes.size();
+  size_t vid_input_count = net_input_vid_sizes.size();
+  size_t bin_input_count = inputs_info.size() - img_input_count - vid_input_count;
+
+  std::vector<std::string> binary_files;
+  std::vector<std::string> image_files;
+  std::vector<std::string> video_files;
+
+  if (input_files.empty()) {
+    slog::warn << "No input files were given: all inputs will be filled with random values!" << slog::endl;
+  } else {
+    binary_files = FilterFilesByExtensions(input_files, supported_binary_extensions);
+    std::sort(std::begin(binary_files), std::end(binary_files));
+
+    auto bins_to_be_used = bin_input_count * batch_size * requests_num;
+    if (bins_to_be_used > 0 && binary_files.empty()) {
+      std::stringstream ss;
+      for (auto& ext : supported_binary_extensions) {
+        if (!ss.str().empty()) {
+          ss << ", ";
+        }
+        ss << ext;
+      }
+      slog::warn << "No supported binary inputs found! Please check your file "
+                    "extensions: "
+                 << ss.str() << slog::endl;
+    } else if (bins_to_be_used > binary_files.size()) {
+      slog::warn << "Some binary input files will be duplicated: " << bins_to_be_used << " files are required but only "
+                 << binary_files.size() << " are provided" << slog::endl;
+    } else if (bins_to_be_used < binary_files.size()) {
+      slog::warn << "Some binary input files will be ignored: only " << bins_to_be_used << " are required from "
+                 << binary_files.size() << slog::endl;
+    }
+
+    image_files = FilterFilesByExtensions(input_files, supported_image_extensions);
+    std::sort(std::begin(image_files), std::end(image_files));
+
+    auto imgs_to_be_used = img_input_count * batch_size * requests_num;
+    if (imgs_to_be_used > 0 && image_files.empty()) {
+      std::stringstream ss;
+      for (auto& ext : supported_image_extensions) {
+        if (!ss.str().empty()) {
+          ss << ", ";
+        }
+        ss << ext;
+      }
+      slog::warn << "No supported image inputs found! Please check your file "
+                    "extensions: "
+                 << ss.str() << slog::endl;
+    } else if (imgs_to_be_used > image_files.size()) {
+      slog::warn << "Some image input files will be duplicated: " << imgs_to_be_used << " files are required but only "
+                 << image_files.size() << " are provided" << slog::endl;
+    } else if (imgs_to_be_used < image_files.size()) {
+      slog::warn << "Some image input files will be ignored: only " << imgs_to_be_used << " are required from "
+                 << image_files.size() << slog::endl;
+    }
+
+    video_files = FilterFilesByExtensions(input_files, supported_video_extensions);
+    std::sort(std::begin(video_files), std::end(video_files));
+    auto vids_to_be_used = vid_input_count * requests_num;
+    if (vids_to_be_used > 0 && video_files.empty()) {
+      std::stringstream ss;
+      for (auto& ext : supported_video_extensions) {
+        if (!ss.str().empty()) {
+          ss << ", ";
+        }
+        ss << ext;
+      }
+      slog::warn << "No supported video inputs found! Please check your file extensions: " << ss.str() << slog::endl;
+    } else if (vids_to_be_used > video_files.size()) {
+      slog::warn << "Some video input files will be duplicated: " << vids_to_be_used << " files are required but only "
+                 << video_files.size() << " are provided" << slog::endl;
+    } else if (vids_to_be_used < video_files.size()) {
+      slog::warn << "Some video input files will be ignored: only " << vids_to_be_used << " are required from "
+                 << video_files.size() << slog::endl;
+    }
+  }
+
+  for (size_t i = 0; i < requests_num; ++i) {
+    size_t img_input_id = 0;
+    size_t bin_input_id = 0;
+    size_t vid_input_id = 0;
+
+    for (auto& item : inputs_info) {
+      const std::string& input_name = item.first;
+      const auto& input_info = item.second;
+      if (item.second.IsImage() && !is_binary_data) {
+        if (!image_files.empty()) {
+          // Fill with images
+          blobs[input_name].push_back(GetImageTensor(
+              image_files, img_input_id++, batch_size, img_input_count, i, {input_name, input_info}, resize_type_enum, bgr, verbose));
+          continue;
+        }
+      } else if (input_info.IsVideo()) {
+        if (!video_files.empty()) {
+          // Fill with videos
+          blobs[input_name].push_back(GetVideoTensor(
+              video_files, vid_input_id++, batch_size, vid_input_count, i, {input_name, input_info}, bgr, verbose));
+          continue;
+        }
+      } else {
+        if (!binary_files.empty()) {
+          // Fill with binary files
+          blobs[input_name].push_back(
+              GetBinaryTensor(binary_files, bin_input_id++, batch_size, bin_input_count, i, {input_name, input_info}, verbose));
+          continue;
+        }
+        if (input_info.IsImageInfo() && (net_input_im_sizes.size() == 1)) {
+          // Most likely it is image info: fill with image information
+          auto image_size = net_input_im_sizes.at(0);
+          blobs[input_name].push_back(GetImInfoTensor(image_size, batch_size, {input_name, input_info}));
+          continue;
+        }
+      }
+      // Fill random
+      slog::info << "No suitable input data found, filling input tensors with random data.\n";
+      blobs[input_name].push_back(GetRandomTensor({input_name, input_info}));
+    }
+  }
+
+  return blobs;
+}
+
+/**
+ * @brief Copies data from a source OpenVINO Tensor to a destination Tensor.
+ *
+ * @param dst The destination Tensor where data will be copied.
+ * @param src The source Tensor from which data will be copied.
+ */
+void CopyTensorData(ov::Tensor& dst, const ov::Tensor& src) {
+  if (src.get_shape() != dst.get_shape() || src.get_byte_size() != dst.get_byte_size()) {
+    throw std::runtime_error(
+        "Source and destination tensors shapes and byte sizes are expected to be equal for data copying.");
+  }
+
+  memcpy(dst.data(), src.data(), src.get_byte_size());
+}