Запуск кількох моделей

Поле	Значення
Категорія	Співпроцесинг PCIe
Складність	Початковий
Орієнтовний час читання	15 minutes
Мітки	PCIe, queues, concurrency, classification, detection

Обидві моделі навмисно використовують різні зображення: ResNet-50 класифікує чітке фото лабрадора, а YOLOv8s виявляє людей і автомобілі на жвавій міській сцені.

Покроковий огляд

Завантаження специфічних для моделі зображень

Перевірте обидва архіви моделей і декодуйте обидва упаковані ресурси, перш ніж займати чергу. Зберігання зображень окремо робить кожен результат значущим і запобігає використанню класифікаційного портрета як навантаження для виявлення об’єктів.

pcie_host/tutorials/026_run_multiple_models/run_multiple_models.cpp

const Args args = parse_args(argc, argv);
for (const auto* model : {kResnetModelPath, kYoloModelPath}) {
  if (!std::filesystem::is_regular_file(model)) {
    throw std::runtime_error(std::string("model does not exist: ") + model);
  }
}
const cv::Mat labrador = cv::imread(kResnetImagePath, cv::IMREAD_COLOR);
const cv::Mat street = cv::imread(kYoloImagePath, cv::IMREAD_COLOR);
if (labrador.empty() || street.empty()) {
  throw std::runtime_error("OpenCV could not decode one of the input images");
}

Призначте одну модель кожній черзі

Створіть два звичайні об’єкти Model. Налаштуйте ResNet-50 із попередньою обробкою зображень ImageNet у черзі 0 і YOLOv8s із попередньою обробкою зображень COCO плюс декодуванням обмежувальних рамок у черзі 1. Помилки під час збирання ідентифікують чергу та модель, які не вдалися; модель, яка вже була зібрана, закривається, якщо друга збірка не вдається.

pcie_host/tutorials/026_run_multiple_models/run_multiple_models.cpp

pcie::Model resnet(kResnetModelPath, classification_options(),
                   connection_for(args, kResnetQueue));
pcie::Model yolo(kYoloModelPath, detection_options(), connection_for(args, kYoloQueue));
try {
  resnet.build(kBuildTimeoutMs);
} catch (const std::exception& error) {
  throw std::runtime_error("queue " + std::to_string(kResnetQueue) +
                           " failed to build ResNet-50: " + error.what());
}
try {
  yolo.build(kBuildTimeoutMs);
} catch (const std::exception& error) {
  resnet.close();
  throw std::runtime_error("queue " + std::to_string(kYoloQueue) +
                           " failed to build YOLOv8s: " + error.what());
}

Запустіть обидві черги одночасно

Запустіть один блокуючий процес виведення зображень для кожної моделі в окремих потоках хоста. Кожен виклик все ще використовує просту синхронну поведінку run, але виклики перекриваються, оскільки вони націлені на різні фізичні черги.

pcie_host/tutorials/026_run_multiple_models/run_multiple_models.cpp

pcie::TensorList classification;
pcie::TensorList detections;
try {
  auto classification_future =
      std::async(std::launch::async, [&] { return resnet.run(labrador, kRunTimeoutMs); });
  auto detection_future =
      std::async(std::launch::async, [&] { return yolo.run(street, kRunTimeoutMs); });
  classification = classification_future.get();
  detections = detection_future.get();
} catch (...) {
  yolo.close();
  resnet.close();
  throw;
}

Інтерпретуйте кожен результат незалежно

Черга 0 повертає один тензор класифікації FP32 і виводить його клас ImageNet з найвищим балом. Черга 1 повертає декодовані записи BBOX і виводить клас виявлення, впевненість і координати вихідного зображення. Закриття будь-якої моделі звільняє лише призначену їй чергу.

pcie_host/tutorials/026_run_multiple_models/run_multiple_models.cpp

const int top1 = top_class(classification);
const auto boxes = parse_boxes(detections);
std::cout << "queue=" << kResnetQueue
          << " model=resnet_50 output_shape=" << shape_string(classification[0].shape)
          << " top1=" << top1;
if (top1 == 208) {
  std::cout << " (Labrador retriever)";
}
std::cout << '\n';
std::cout << "queue=" << kYoloQueue << " model=yolo_v8s detections=" << boxes.size() << '\n';
for (std::size_t index = 0; index < std::min<std::size_t>(boxes.size(), 5); ++index) {
  const auto& box = boxes[index];
  std::cout << "  " << class_name(box.class_id) << " score=" << std::fixed
            << std::setprecision(3) << box.score << " box=(" << box.x << ", " << box.y << ", "
            << box.width << ", " << box.height << ")\n";
}
if (boxes.empty()) {
  throw std::runtime_error("YOLOv8s returned no street-scene detections");
}

Запуск

Встановіть пакет хоста PCIe та завантажте пакет для посібника, як описано в Налаштування навчального посібника.. З кореневої папки додаткових матеріалів PCIe, завантажте обидві моделі:

sima-cli modelzoo get resnet_50
sima-cli modelzoo get yolo_v8s

Програма вимагає точних шляхів до resnet_50_mpk.tar.gz і yolo_v8s_mpk.tar.gz у цьому каталозі. Якщо Model Zoo використовував інші імена або розташування, скопіюйте завантажені архіви на відповідні місця та перевірте їх:

cp /absolute/path/to/downloaded-resnet-archive.tar.gz resnet_50_mpk.tar.gz
cp /absolute/path/to/downloaded-yolov8s-archive.tar.gz yolo_v8s_mpk.tar.gz
test -f resnet_50_mpk.tar.gz
test -f yolo_v8s_mpk.tar.gz

Запустіть Python:

source ~/pyneatpcie/bin/activate
python3 share/sima-pcie-host/tutorials/026_run_multiple_models/run_multiple_models.py

Запустіть попередньо зібраний посібник C++:

./lib/sima-pcie-host/tutorials/tutorial_026_run_multiple_models

Або перезберіть його:

./build.sh --target tutorial_026_run_multiple_models
./build/tutorials-standalone/tutorial_026_run_multiple_models

За наявності задокументованих моделей і ресурсів, обидві версії виводять результати, подібні до:

queue=0 model=resnet_50 output_shape=[1, 1000] top1=208 (Labrador retriever)
queue=1 model=yolo_v8s detections=...
  person score=... box=(...)
[OK] 026_run_multiple_models

У посібнику ResNet-50 навмисно фіксується до черги 0, а YOLOv8s – до черги 1. Передавайте --card N лише під час використання іншої карти.

На практиці

Призначення черги є рішенням щодо ресурсів застосунку: дві активні моделі не можуть використовувати одну й ту саму фізичну чергу. Збирайте моделі перед початком роботи, повідомляйте про конкретну чергу у разі збою та закривайте кожну успішно зібрану модель як у звичайних, так і в аварійних сценаріях. Окремі екземпляри Model зберігають результати та збої ізольованими, залишаючись при цьому простими для розуміння.

Для діагностики розгортання продовжуйте роботу з Модель робочого процесу PCIe і посібник з усунення несправностей.

Повний початковий код

Показати повні програми

pcie_host/tutorials/026_run_multiple_models/run_multiple_models.cpp

// Run ResNet-50 and YOLOv8s concurrently on two PCIe queues.
//
// Usage:
//   tutorial_026_run_multiple_models

#include <simaai/neat/pcie/Model.h>

#include <opencv2/imgcodecs.hpp>

#include <algorithm>
#include <cstdint>
#include <cstring>
#include <cstdlib>
#include <filesystem>
#include <future>
#include <iomanip>
#include <iostream>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

namespace pcie = simaai::neat::pcie;

namespace {

constexpr int kBuildTimeoutMs = 180000;
constexpr int kRunTimeoutMs = 30000;
constexpr int kResnetQueue = 0;
constexpr int kYoloQueue = 1;
constexpr char kResnetModelPath[] = "resnet_50_mpk.tar.gz";
constexpr char kYoloModelPath[] = "yolo_v8s_mpk.tar.gz";
constexpr char kResnetImagePath[] = "share/sima-pcie-host/tutorials/assets/labrador.jpg";
constexpr char kYoloImagePath[] = "share/sima-pcie-host/tutorials/assets/street-scene.png";

struct Args {
  int card_id = 0;
};

std::string require_value(int argc, char** argv, int& index, const char* option) {
  if (index + 1 >= argc) {
    throw std::runtime_error(std::string("missing value for ") + option);
  }
  return argv[++index];
}

Args parse_args(int argc, char** argv) {
  Args args;
  for (int index = 1; index < argc; ++index) {
    const std::string arg = argv[index];
    if (arg == "--card") {
      args.card_id = std::stoi(require_value(argc, argv, index, "--card"));
    } else if (arg == "-h" || arg == "--help") {
      std::cout << "Usage: " << argv[0] << " [--card 0]\n";
      std::exit(0);
    } else {
      throw std::runtime_error("unknown argument: " + arg);
    }
  }
  return args;
}

pcie::ConnectionOptions connection_for(const Args& args, const int queue) {
  pcie::ConnectionOptions connection;
  connection.card_id = args.card_id;
  connection.queue = queue;
  return connection;
}

pcie::ModelOptions classification_options() {
  pcie::ModelOptions options;
  options.preprocess.kind = pcie::InputKind::Image;
  options.preprocess.color_convert.input_format = pcie::ColorFormat::BGR;
  options.preprocess.color_convert.output_format = pcie::ColorFormat::RGB;
  options.preprocess.resize.enable = pcie::AutoFlag::On;
  options.preprocess.resize.mode = pcie::ResizeMode::Stretch;
  options.preprocess.normalize.preset = pcie::NormalizePreset::ImageNet;
  return options;
}

pcie::ModelOptions detection_options() {
  pcie::ModelOptions options;
  options.preprocess.kind = pcie::InputKind::Image;
  options.preprocess.color_convert.input_format = pcie::ColorFormat::BGR;
  options.preprocess.color_convert.output_format = pcie::ColorFormat::RGB;
  options.preprocess.resize.enable = pcie::AutoFlag::On;
  options.preprocess.resize.mode = pcie::ResizeMode::Letterbox;
  options.preprocess.normalize.preset = pcie::NormalizePreset::COCO_YOLO;
  options.decode_type = pcie::BoxDecodeType::YoloV8;
  options.score_threshold = 0.25F;
  options.nms_iou_threshold = 0.45F;
  options.top_k = 100;
  return options;
}

std::string shape_string(const std::vector<std::int64_t>& shape) {
  std::string text = "[";
  for (std::size_t index = 0; index < shape.size(); ++index) {
    text += (index == 0 ? "" : ", ") + std::to_string(shape[index]);
  }
  return text + "]";
}

int top_class(const pcie::TensorList& outputs) {
  if (outputs.size() != 1 || outputs[0].dtype != pcie::TensorDType::Float32 ||
      outputs[0].data == nullptr || outputs[0].byte_offset < 0) {
    throw std::runtime_error("ResNet-50 must return one populated FP32 tensor");
  }
  const auto& output = outputs[0];
  const auto offset = static_cast<std::size_t>(output.byte_offset);
  if (offset > output.size_bytes || (output.size_bytes - offset) % sizeof(float) != 0) {
    throw std::runtime_error("ResNet-50 returned an invalid output span");
  }
  const auto* scores =
      reinterpret_cast<const float*>(static_cast<const std::uint8_t*>(output.data) + offset);
  const std::size_t count = (output.size_bytes - offset) / sizeof(float);
  return static_cast<int>(std::distance(scores, std::max_element(scores, scores + count)));
}

struct Box {
  int x;
  int y;
  int width;
  int height;
  float score;
  int class_id;
};

template <typename T> T read_value(const std::uint8_t* data) {
  T value{};
  std::memcpy(&value, data, sizeof(value));
  return value;
}

std::vector<Box> parse_boxes(const pcie::TensorList& outputs) {
  if (outputs.size() != 1 || outputs[0].data == nullptr || outputs[0].byte_offset < 0) {
    throw std::runtime_error("YOLOv8 boxdecode must return one populated BBOX tensor");
  }
  const auto& tensor = outputs[0];
  const auto offset = static_cast<std::size_t>(tensor.byte_offset);
  if (offset > tensor.size_bytes || tensor.size_bytes - offset < 4) {
    throw std::runtime_error("BBOX tensor is too small");
  }
  const auto* bytes = static_cast<const std::uint8_t*>(tensor.data) + offset;
  const std::size_t available = tensor.size_bytes - offset;
  const auto count = read_value<std::uint32_t>(bytes);
  constexpr std::size_t record_size = 24;
  if (count > (available - 4) / record_size) {
    throw std::runtime_error("BBOX detection count exceeds its payload");
  }
  std::vector<Box> boxes;
  boxes.reserve(count);
  for (std::uint32_t index = 0; index < count; ++index) {
    const auto* record = bytes + 4 + index * record_size;
    boxes.push_back({read_value<std::int32_t>(record), read_value<std::int32_t>(record + 4),
                     read_value<std::int32_t>(record + 8), read_value<std::int32_t>(record + 12),
                     read_value<float>(record + 16), read_value<std::int32_t>(record + 20)});
  }
  return boxes;
}

std::string class_name(const int class_id) {
  switch (class_id) {
  case 0:
    return "person";
  case 1:
    return "bicycle";
  case 2:
    return "car";
  case 3:
    return "motorcycle";
  case 5:
    return "bus";
  case 7:
    return "truck";
  default:
    return "class_" + std::to_string(class_id);
  }
}

} // namespace

int main(int argc, char** argv) {
  try {
    const Args args = parse_args(argc, argv);
    for (const auto* model : {kResnetModelPath, kYoloModelPath}) {
      if (!std::filesystem::is_regular_file(model)) {
        throw std::runtime_error(std::string("model does not exist: ") + model);
      }
    }
    const cv::Mat labrador = cv::imread(kResnetImagePath, cv::IMREAD_COLOR);
    const cv::Mat street = cv::imread(kYoloImagePath, cv::IMREAD_COLOR);
    if (labrador.empty() || street.empty()) {
      throw std::runtime_error("OpenCV could not decode one of the input images");
    }

    pcie::Model resnet(kResnetModelPath, classification_options(),
                       connection_for(args, kResnetQueue));
    pcie::Model yolo(kYoloModelPath, detection_options(), connection_for(args, kYoloQueue));
    try {
      resnet.build(kBuildTimeoutMs);
    } catch (const std::exception& error) {
      throw std::runtime_error("queue " + std::to_string(kResnetQueue) +
                               " failed to build ResNet-50: " + error.what());
    }
    try {
      yolo.build(kBuildTimeoutMs);
    } catch (const std::exception& error) {
      resnet.close();
      throw std::runtime_error("queue " + std::to_string(kYoloQueue) +
                               " failed to build YOLOv8s: " + error.what());
    }

    // CORE LOGIC
    pcie::TensorList classification;
    pcie::TensorList detections;
    try {
      auto classification_future =
          std::async(std::launch::async, [&] { return resnet.run(labrador, kRunTimeoutMs); });
      auto detection_future =
          std::async(std::launch::async, [&] { return yolo.run(street, kRunTimeoutMs); });
      classification = classification_future.get();
      detections = detection_future.get();
    } catch (...) {
      yolo.close();
      resnet.close();
      throw;
    }

    const int top1 = top_class(classification);
    const auto boxes = parse_boxes(detections);
    std::cout << "queue=" << kResnetQueue
              << " model=resnet_50 output_shape=" << shape_string(classification[0].shape)
              << " top1=" << top1;
    if (top1 == 208) {
      std::cout << " (Labrador retriever)";
    }
    std::cout << '\n';
    std::cout << "queue=" << kYoloQueue << " model=yolo_v8s detections=" << boxes.size() << '\n';
    for (std::size_t index = 0; index < std::min<std::size_t>(boxes.size(), 5); ++index) {
      const auto& box = boxes[index];
      std::cout << "  " << class_name(box.class_id) << " score=" << std::fixed
                << std::setprecision(3) << box.score << " box=(" << box.x << ", " << box.y << ", "
                << box.width << ", " << box.height << ")\n";
    }
    if (boxes.empty()) {
      throw std::runtime_error("YOLOv8s returned no street-scene detections");
    }

    yolo.close();
    resnet.close();
    std::cout << "[OK] 026_run_multiple_models\n";
    return 0;
  } catch (const std::exception& error) {
    std::cerr << "[FAIL] " << error.what() << '\n';
    return 1;
  }
}

Джерело

• C++
• Python
• README