YOLOv5n model does work on python tflite but not C++ tflite
Are you satisfied with the resolution of your issue?
<a href="https://docs.google.com/forms/d/e/1FAIpQLSfaP12TRhd9xSxjXZjcZFNXPGk4kc1-qMdv3gc6bEP90vY1ew/viewform?entry.85265664=Yes&entry.2137816233=https://github.com/tensorflow/tensorflow/issues/69510">Yes</a>
<a href="https://docs.google.com/forms/d/e/1FAIpQLSfaP12TRhd9xSxjXZjcZFNXPGk4kc1-qMdv3gc6bEP90vY1ew/viewform?entry.85265664=No&entry.2137816233=https://github.com/tensorflow/tensorflow/issues/69510">No</a>

**System information**
Linux with tensorflow v2.16.1

**Standalone code to reproduce the issue**
I exported YOLOv5n integer quantized model from ultralytics.
I tested with python tflite code, and it worked fine.
But when I ported it to C++ tflite code, it did not work.
All the output score value is 0.
The output x,y,w,h value is not 0.

**Any other info / logs**
I attatched the exported YOLOv5n model.
https://1drv.ms/u/s!AnqHHtrBqwyUg8QHviF7T1KqPkXeog?e=c3fasi


The code I used it for C++ is as bellows.
```c++
std::unique_ptr<tflite::FlatBufferModel> model = tflite::FlatBufferModel::BuildFromFile("yolov5nu_integer_quant.tflite");

tflite::ops::builtin::BuiltinOpResolver resolver;
tflite::InterpreterBuilder builder(*model, resolver);
std::unique_ptr<tflite::Interpreter> interpreter;
builder(&interpreter);

interpreter->AllocateTensors();

TfLiteTensor* input_tensor_0 = interpreter->input_tensor(0);
TfLiteIntArray* input_dims = input_tensor_0->dims;
int input_height = input_dims->data[1];
int input_width = input_dims->data[2];
int input_channel = input_dims->data[3];

float * input_img_ptr = new float[input_height * input_width * input_channel];
memset(input_img_ptr, 0, input_height * input_width * input_channel * sizeof(float));

... //image decode and resize it as resize_img_ptr

for(int i = 0; i < resize_height; i++){
    for(int j = 0; j < resize_width; j++){
        int input_idx = i * input_width + j;
        int resize_idx = i * resize_width + j;

        input_img_ptr[3 * input_idx] = resize_img_ptr[3 * resize_idx] / 255.0;
        input_img_ptr[3 * input_idx + 1] = resize_img_ptr[3 * resize_idx + 1] / 255.0;
        input_img_ptr[3 * input_idx + 2] = resize_img_ptr[3 * resize_idx + 2] / 255.0;
    }
}

memcpy(interpreter->typed_input_tensor<float>(0), input_img_ptr, input_height * input_width * input_channel * sizeof(float));
delete input_img_ptr;

interpreter->Invoke();

float * output = interpreter->typed_output_tensor<float>(0);
float (*output_arr)[output_width] = (float(*)[output_width])output;

TfLiteTensor* output_tensor_0 = interpreter->output_tensor(0);
TfLiteIntArray* output_dims = output_tensor_0->dims;
int output_height = output_dims->data[1];
int output_width = output_dims->data[2];

for(int i = 0; i < output_width; i++){
    float x = output_arr[0][i];
    float y = output_arr[1][i];
    float w = output_arr[2][i];
    float h = output_arr[3][i];
    
    float xmin = (x - 0.5 * w) * input_width / scale_width ;
    float ymin = (y - 0.5 * h) * input_height / scale_height ;
    float width = w * input_width / scale_width;
    float height = h * input_height / scale_height;
    
    float max_score = 0;
    int max_class_id = 0;
    
    for(int j = 4; j < output_height; j++){
        float score = output_arr[j][i];
    
        int class_id = j - 4;
    
        if(score > max_score){
            max_score = score;
            max_class_id = class_id;
        }
    
        std::cout << i << ", "<< j <<  ": class_id: " << class_id << ", score: " << score << ", xn: " << x << ", y: " << y << ", w: " << w << ", h: "<< h << std::endl;
 }
``` 
