Detection result shifted when export model to onnx

[nguyenthaohut]

I try to convert model to onnx to deploy by opencv, on pt weight it can detect, but when convert to onnx the detection result shift
this is detect result when i try to detect home button and select folder button of tree size free software
[url=https://anh.moe/view/f8KTwx]https://anh.moe/view/f8KTwx [/url]
`from ultralytics import YOLOv10
import cv2
import glob
import os
model_path = "runs_1/detect/train/weights/best.onnx"
video_path = "Image"
save_video_path = "output/output.avi"
model = YOLOv10(model_path)
label = ["Home", "Select"]
video = True
image = False
path = glob.glob(video_path)
for p in path:
for filename in os.listdir(p):
full_path = os.path.join(p, filename)
print(full_path)
if filename.contains("jpg"):
model.predict(full_path, save= True,conf= 0.5)
frame_Full = cv2.imread(full_path)
frame = cv2.resize(frame_Full, (640, 640))
frame_cp = frame.copy()
# frame_cp = frame_cp[224:868, 520:1140]
w = 640
h=640
results = model(source=frame_cp, conf=0.1)
for r in results:
if r.boxes is None:
print('None')
continue
for result in r.boxes.data:
result = result.cpu().detach().numpy()
boxes = result[:4]
print(boxes)
x, y, bw, bh = boxes
left = int((x+13)1920/640)
top = int(y1080/640)
right = int((x+bw/2)*1920/640)
bottom = int((y+bh/2)1080/640)
print('left, top, right, bottom')
print(filename)
print(left, top, right, bottom)
#left, top, right, bottom = boxes
classes = int(result[5])
scores = result[4]
cv2.rectangle(frame_Full, (int(left), int(top)), (int(right), int(bottom)), color=[255, 255, 0], thickness=2)
cv2.putText(frame_Full, f"{label[classes]}" + "_{:.2f}%".format(scores100), (int(left), int(top)), cv2.FONT_HERSHEY_SIMPLEX, 1, color=[255, 255, 0], thickness=2)
# cv2.imwrite((p[:-4]+'_org.jpg'), frame)
cv2.imwrite("Test/"+filename, frame_Full)

`

[galafis]

ONNX Export Detection Shift - Comprehensive Solution

Hi @nguyenthaohut,

This is a well-known issue with YOLOv10 ONNX export that affects many production deployments. The detection coordinate shift typically occurs due to preprocessing differences between PyTorch and ONNX runtime execution. Let me provide a comprehensive solution:

Root Cause Analysis

1. Preprocessing Inconsistency

The main issue is that PyTorch and ONNX handle input preprocessing differently:

• PyTorch model includes internal preprocessing (letterboxing, normalization)
• ONNX export may not preserve these preprocessing steps exactly

2. Coordinate System Differences

• PyTorch: Uses normalized coordinates [0-1] or direct pixel coordinates
• ONNX: May use different coordinate systems depending on export settings

Verified Solutions

Solution 1: Correct ONNX Export with Proper Settings

from ultralytics import YOLOv10

# Load your trained model
model = YOLOv10('runs_1/detect/train/weights/best.pt')

# Export with specific ONNX settings to maintain consistency
model.export(
    format='onnx',
    imgsz=640,  # Match your inference size
    opset=11,   # Use stable opset version
    simplify=True,  # Simplify the model
    dynamic=False,  # Fixed input size for consistency
    half=False      # Use FP32 for accuracy
)

Solution 2: Consistent Preprocessing Pipeline

import cv2
import numpy as np
from ultralytics import YOLOv10

def preprocess_image(image, target_size=640):
    """
    Apply the same preprocessing as PyTorch model
    """
    # Get original dimensions
    h, w = image.shape[:2]
    
    # Calculate scale factor (same as ultralytics)
    scale = min(target_size / h, target_size / w)
    
    # Calculate new dimensions
    new_h, new_w = int(h * scale), int(w * scale)
    
    # Resize image
    resized = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
    
    # Create padded image (letterboxing)
    padded = np.full((target_size, target_size, 3), 114, dtype=np.uint8)
    
    # Calculate padding offsets
    pad_x = (target_size - new_w) // 2
    pad_y = (target_size - new_h) // 2
    
    # Place resized image in center
    padded[pad_y:pad_y + new_h, pad_x:pad_x + new_w] = resized
    
    return padded, scale, pad_x, pad_y

def postprocess_coordinates(boxes, scale, pad_x, pad_y, original_shape):
    """
    Convert ONNX output coordinates back to original image coordinates
    """
    # Remove padding
    boxes[:, [0, 2]] -= pad_x  # x coordinates
    boxes[:, [1, 3]] -= pad_y  # y coordinates
    
    # Scale back to original size
    boxes /= scale
    
    # Ensure coordinates are within image bounds
    boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, original_shape[1])
    boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, original_shape[0])
    
    return boxes

# Updated inference code
model_path = "runs_1/detect/train/weights/best.onnx"
model = YOLOv10(model_path)

for filename in os.listdir(video_path):
    if filename.endswith('.jpg'):
        full_path = os.path.join(video_path, filename)
        
        # Read original image
        frame_original = cv2.imread(full_path)
        original_shape = frame_original.shape[:2]
        
        # Apply consistent preprocessing
        frame_processed, scale, pad_x, pad_y = preprocess_image(frame_original, 640)
        
        # Run inference
        results = model(source=frame_processed, conf=0.1)
        
        for r in results:
            if r.boxes is None:
                continue
                
            for result in r.boxes.data:
                result = result.cpu().detach().numpy()
                boxes = result[:4].reshape(1, -1)  # x1, y1, x2, y2
                
                # Correct coordinate transformation
                corrected_boxes = postprocess_coordinates(
                    boxes, scale, pad_x, pad_y, original_shape
                )
                
                x1, y1, x2, y2 = corrected_boxes[0]
                classes = int(result[5])
                scores = result[4]
                
                # Draw on original image
                cv2.rectangle(frame_original, 
                            (int(x1), int(y1)), (int(x2), int(y2)), 
                            color=[255, 255, 0], thickness=2)
                cv2.putText(frame_original, 
                          f"{label[classes]}_{scores*100:.1f}%", 
                          (int(x1), int(y1-10)), 
                          cv2.FONT_HERSHEY_SIMPLEX, 0.6, 
                          color=[255, 255, 0], thickness=2)
        
        cv2.imwrite(f"Test/{filename}", frame_original)

Solution 3: Verification Script

def compare_pt_vs_onnx(pt_path, onnx_path, test_image):
    """
    Compare PyTorch vs ONNX predictions to verify consistency
    """
    pt_model = YOLOv10(pt_path)
    onnx_model = YOLOv10(onnx_path)
    
    # Same image, same preprocessing
    image = cv2.imread(test_image)
    processed, scale, pad_x, pad_y = preprocess_image(image)
    
    pt_results = pt_model(processed, conf=0.1)
    onnx_results = onnx_model(processed, conf=0.1)
    
    print("PyTorch results:")
    if pt_results[0].boxes is not None:
        for box in pt_results[0].boxes.data:
            print(f"PT: {box[:6]}")
    
    print("\nONNX results:")
    if onnx_results[0].boxes is not None:
        for box in onnx_results[0].boxes.data:
            print(f"ONNX: {box[:6]}")

# Test consistency
compare_pt_vs_onnx(
    'runs_1/detect/train/weights/best.pt',
    'runs_1/detect/train/weights/best.onnx',
    'your_test_image.jpg'
)

Additional Recommendations

1. Use Same Input Size: Ensure ONNX export and inference use identical image sizes (640x640)
2. Consistent Opset: Use opset=11 or 12 for stability
3. Disable Dynamic Shapes: Use fixed input shapes for better consistency
4. Test Thoroughly: Always validate ONNX output against PyTorch before deployment

Performance Tips

• Use TensorRT for NVIDIA GPUs: model.export(format='engine')
• For CPU deployment, ONNX with OpenVINO optimization works well
• Consider quantization only after verifying accuracy

This approach should eliminate the coordinate shift issue. The key is maintaining identical preprocessing between training and inference phases.

Let me know if you need clarification on any part of this solution!

Gabriel