メインコンテンツまでスキップ

複数のモデルを実行

項目値
カテゴリPCIe コプロセッシング
難易度初級
推定所要時間15 minutes
ラベルPCIe, queues, concurrency, classification, detection

2つのモデルは、意図的に異なる画像を使用します。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");
}

各キューに1つのモデルを割り当てる​

2つの通常のModelオブジェクトを作成します。ResNet-50を、ImageNet画像の前処理とともにキュー0に、YOLOv8sを、COCO画像の前処理とボックスデコードとともにキュー1に設定します。ビルドエラーが発生した場合、エラーが発生したキューとモデルが特定されます。すでにビルドされたモデルは、2回目のビルドが失敗した場合に閉じられます。

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());
}

両方のキューを同時に実行する​

各モデルに対して、ホストの別々のスレッドで1つのブロッキング画像推論を開始します。各呼び出しは、単純な同期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は、1つの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を渡します。

実践​

キューの割り当ては、アプリケーションのリソースに関する決定です。2つのアクティブなモデルは、同じ物理キューを所有することはできません。モデルは、作業を開始する前にビルドし、失敗時に特定のキューを報告し、正常にビルドされたすべてのモデルを、正常な場合とエラーの場合の両方で閉じます。個別の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;
  }
}

ソース​