Error loading ONNX file (converted YOLOv7 model) in OnnxRuntime/C++ - c++

Question

I trained a model in YOLOv7 in python, and then converted the model to ONNX in order to open it in C++ with OpenCV.
It seems to work fine in python on collab, but when I try to run it in C++
Inference Execution Provider: CPU
Num Input Nodes: 1
Num Output Nodes: 1
Input Name: images
Input Type: float
Input Dimensions: [1, 3, 640, 640]
Output Name: output
Output Type: float
Output Dimensions: [-1, 7]
input tensor size: 1228800
output tensor size: 18446744073709551609
terminate called after throwing an instance of 'std::length_error'
what(): cannot create std::vector larger than max_size()
Aborted (core dumped)
It seems to get the output dimensions wrong somehow, which leads to a -1, and then the output size becomes a negative number which when converted to a signed 64-bit integer becomes astronomical and crashes the program when it tries to allocate the vector. But why is it reading it wrong?
The code I'm trying to run is from here:
https://github.com/Neuralearn/onnx_cplusplus/blob/main/main.cpp
int main(int argc, char* argv[])
{
bool useCUDA{false};
const char* useCUDAFlag = "--use_cuda";
const char* useCPUFlag = "--use_cpu";
if (argc == 1)
{
useCUDA = false;
}
else if ((argc == 2) && (strcmp(argv[1], useCUDAFlag) == 0))
{
useCUDA = true;
}
else if ((argc == 2) && (strcmp(argv[1], useCPUFlag) == 0))
{
useCUDA = false;
}
else if ((argc == 2) && (strcmp(argv[1], useCUDAFlag) != 0))
{
useCUDA = false;
}
else
{
throw std::runtime_error{"Too many arguments."};
}
if (useCUDA)
{
std::cout << "Inference Execution Provider: CUDA" << std::endl;
}
else
{
std::cout << "Inference Execution Provider: CPU" << std::endl;
}
/*****************************************************************************************************************/
std::string instanceName{"image-classification-inference"};
//std::string modelFilepath{"best_yolox_nano.onnx"};
std::string modelFilepath{"best.onnx"};
//std::string imageFilepath{"demo.jpg"};
std::string imageFilepath{"train1.jpg"};
std::string labelFilepath{"synset.txt"};
std::vector<std::string> labels{readLabels(labelFilepath)};
//cerr<<"aaaa"<<endl;
Ort::Env env(OrtLoggingLevel::ORT_LOGGING_LEVEL_WARNING,
instanceName.c_str());
Ort::SessionOptions sessionOptions;
sessionOptions.SetIntraOpNumThreads(1);
//cerr<<"bbb"<<endl;
sessionOptions.SetGraphOptimizationLevel(
GraphOptimizationLevel::ORT_ENABLE_EXTENDED);
Ort::Session session(env, modelFilepath.c_str(), sessionOptions);
Ort::AllocatorWithDefaultOptions allocator;
size_t numInputNodes = session.GetInputCount();
size_t numOutputNodes = session.GetOutputCount();
//cerr<<"ccc"<<endl;
std::cout << "Num Input Nodes: " << numInputNodes << std::endl;
std::cout << "Num Output Nodes: " << numOutputNodes << std::endl;
const char* inputName = session.GetInputName(0, allocator);
std::cout << "Input Name: " << inputName << std::endl;
Ort::TypeInfo inputTypeInfo = session.GetInputTypeInfo(0);
auto inputTensorInfo = inputTypeInfo.GetTensorTypeAndShapeInfo();
ONNXTensorElementDataType inputType = inputTensorInfo.GetElementType();
std::cout << "Input Type: " << inputType << std::endl;
std::vector<int64_t> inputDims = inputTensorInfo.GetShape();
std::cout << "Input Dimensions: " << inputDims << std::endl;
const char* outputName = session.GetOutputName(0, allocator);
std::cout << "Output Name: " << outputName << std::endl;
Ort::TypeInfo outputTypeInfo = session.GetOutputTypeInfo(0);
auto outputTensorInfo = outputTypeInfo.GetTensorTypeAndShapeInfo();
ONNXTensorElementDataType outputType = outputTensorInfo.GetElementType();
std::cout << "Output Type: " << outputType << std::endl;
std::vector<int64_t> outputDims = outputTensorInfo.GetShape();
std::cout << "Output Dimensions: " << outputDims << std::endl;
cv::Mat imageBGR = cv::imread(imageFilepath, cv::ImreadModes::IMREAD_COLOR);
cv::Mat preprocessedImage;
cv::Mat resizedImage = static_resize(imageBGR);
cv::dnn::blobFromImage(resizedImage, preprocessedImage);
// cv::imwrite("image.jpg", resizedImage);
size_t inputTensorSize = vectorProduct(inputDims);
cerr<<"input tensor size: "<<inputTensorSize<<endl;
std::vector<float> inputTensorValues(inputTensorSize);
inputTensorValues.assign(preprocessedImage.begin<float>(),
preprocessedImage.end<float>());
size_t outputTensorSize = vectorProduct(outputDims);
for (auto x : outputDims) cerr << x<< " "; cerr<<endl;
cerr<<"output tensor size: "<<outputTensorSize<<endl;
std::vector<float> outputTensorValues(outputTensorSize);
std::vector<const char*> inputNames{inputName};
std::vector<const char*> outputNames{outputName};
std::vector<Ort::Value> inputTensors;
std::vector<Ort::Value> outputTensors;
Ort::MemoryInfo memoryInfo = Ort::MemoryInfo::CreateCpu(
OrtAllocatorType::OrtArenaAllocator, OrtMemType::OrtMemTypeDefault);
inputTensors.push_back(Ort::Value::CreateTensor<float>(
memoryInfo, inputTensorValues.data(), inputTensorSize, inputDims.data(),
inputDims.size()));
outputTensors.push_back(Ort::Value::CreateTensor<float>(
memoryInfo, outputTensorValues.data(), outputTensorSize,
outputDims.data(), outputDims.size()));
session.Run(Ort::RunOptions{nullptr}, inputNames.data(),
inputTensors.data(), 1, outputNames.data(),
outputTensors.data(), 1);
cv::Mat image = imread_t(imageFilepath);
int img_w = image.cols;
int img_h = image.rows;
float scale = std::min(INPUT_W / (image.cols*1.0), INPUT_H / (image.rows*1.0));
std::vector<Object> objects;
const float * net_pred = outputTensorValues.data();
decode_outputs(net_pred, objects, scale, img_w, img_h);
draw_objects(image, objects);
}