test_py_cpp_contract.cpp File Reference

#include "pcod_common/model_manifest.hpp"
#include "pcod_common/nms.hpp"
#include "pcod_common/version.hpp"
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

Go to the source code of this file.

Functions
int	main ()

Function Documentation

main()

int main

(

)

Run C++ and Python contract parity checks.

Definition at line 160 of file test_py_cpp_contract.cpp.

           {
  const std::string python_dir = PCOD_COMMON_PYTHON_DIR;
  const std::string py_prefix = "PYTHONPATH='" + python_dir + "' python3 -c \"";
 
  {
    const auto result = RunCommandCapture(py_prefix + "from pcod_common.manifest import SCHEMA_VERSION; print(SCHEMA_VERSION)\"");
    assert(result.exit_code == 0);
    assert(Trim(result.stdout_text) == pcod_common::kManifestSchemaVersion);
  }
 
  {
    const auto result = RunCommandCapture(py_prefix +
                                          "from pcod_common.manifest import score_threshold_list as s; "
                                          "print(','.join(str(v) for v in s(None))); "
                                          "print(','.join(str(v) for v in s(0.25))); "
                                          "print(','.join(str(v) for v in s([0.1, 0.2])))\"");
    assert(result.exit_code == 0);
    const auto lines = SplitLines(result.stdout_text);
    assert(lines.size() == 3);
    assert(lines[0].empty());
    assert(lines[1] == "0.25");
    assert(lines[2] == "0.1,0.2");
  }
 
  {
    const std::string scalar_path = "./test_py_cpp_score_scalar.yml";
    const std::string list_path = "./test_py_cpp_score_list.yml";
    WriteManifestWithScoreThreshold(scalar_path, "0.2");
    WriteManifestWithScoreThreshold(list_path, "[0.1, 0.2, 0.3]");
 
    auto scalar_manifest = pcod_common::LoadModelManifest(scalar_path);
    auto list_manifest = pcod_common::LoadModelManifest(list_path);
 
    assert(scalar_manifest.runtime_defaults.postprocessing.nms_score_thresholds.size() == 1);
    assert(std::abs(scalar_manifest.runtime_defaults.postprocessing.nms_score_thresholds[0] - 0.2f) < 1e-6f);
    assert(list_manifest.runtime_defaults.postprocessing.nms_score_thresholds.size() == 3);
    assert(std::abs(list_manifest.runtime_defaults.postprocessing.nms_score_thresholds[0] - 0.1f) < 1e-6f);
    assert(std::abs(list_manifest.runtime_defaults.postprocessing.nms_score_thresholds[1] - 0.2f) < 1e-6f);
    assert(std::abs(list_manifest.runtime_defaults.postprocessing.nms_score_thresholds[2] - 0.3f) < 1e-6f);
  }
 
  {
    const auto torch_check = RunCommandCapture(py_prefix + "import torch, torchvision; print('ok')\"");
    if (torch_check.exit_code == 0) {
      pcod_common::BoundingBox a;
      a.center = {0.0f, 0.0f};
      a.length = 1.0f;
      a.width = 1.0f;
      a.existence_probability = 0.9f;
      a.classification.push_back({0, 1.0f});
 
      pcod_common::BoundingBox b = a;
      b.center = {0.1f, 0.0f};
      b.existence_probability = 0.8f;
 
      pcod_common::BoundingBox c = a;
      c.center = {10.0f, 0.0f};
      c.existence_probability = 0.7f;
 
      std::vector<pcod_common::BoundingBox> boxes = {a, b, c};
      pcod_common::NmsConfig cfg;
      cfg.score_thresholds = {0.5f};
      cfg.iou_threshold = 0.1f;
      cfg.max_detections = 10;
      cfg.internal_score_threshold = 0.5f;
      pcod_common::ApplyRotatedNms(boxes, cfg);
 
      std::vector<float> cpp_kept_x;
      for (const auto& box : boxes) {
        cpp_kept_x.push_back(box.center[0]);
      }
 
      const auto py_nms = RunCommandCapture(py_prefix +
                                            "from pcod_common.postprocess import apply_nms; "
                                            "import torch; "
                                            "boxes=torch.tensor([[0.0,0.0,0.0,1.0,1.0,1.0,0.0],[0.1,0.0,0.0,1.0,1.0,1.0,0.0],[10."
                                            "0,0.0,0.0,1.0,1.0,1.0,0.0]],dtype=torch.float32); "
                                            "scores=torch.tensor([0.9,0.8,0.7],dtype=torch.float32); "
                                            "labels=torch.tensor([0,0,0],dtype=torch.long); "
                                            "kept_boxes,_,_=apply_nms(boxes,scores,labels,[0.5],0.1,10,use_rotated=False); "
                                            "print(','.join(str(float(v)) for v in kept_boxes[:,0].tolist()))\"");
      assert(py_nms.exit_code == 0);
 
      const auto py_kept_x = ParseCsvFloats(py_nms.stdout_text);
      assert(py_kept_x.size() == cpp_kept_x.size());
      for (std::size_t i = 0; i < py_kept_x.size(); ++i) {
        assert(std::abs(py_kept_x[i] - cpp_kept_x[i]) < 1e-5f);
      }
    }
  }
 
  return 0;
}

References pcod_common::ApplyRotatedNms(), pcod_common::BoundingBox::center, pcod_common::BoundingBox::classification, pcod_common::BoundingBox::existence_probability, pcod_common::NmsConfig::internal_score_threshold, pcod_common::NmsConfig::iou_threshold, pcod_common::kManifestSchemaVersion, pcod_common::BoundingBox::length, pcod_common::LoadModelManifest(), pcod_common::NmsConfig::max_detections, pcod_common::NmsConfig::score_thresholds, and pcod_common::BoundingBox::width.