Hi everyone,
I’m currently studying the conversion of a pose estimation model into the HEF format. I have some doubts: apparently, providing a folder with 100 images for optimization yields better results than using 200 or even 1000 images.
Specifically, I analyzed the outputs of different models (all starting from the same ONNX file, with the only difference being the dataset used for optimization — initially 100 random images, then 200 supposedly more suitable ones, and finally 1000), and tested them on the same input images.
Surprisingly, the model optimized with 100 images performs better — the keypoints appear noticeably more accurate to the eye. Even worse, the model optimized with 1000 images fails to detect any keypoints at all.
At this point, I’m wondering what I might be doing wrong. How is this behavior possible? What am I missing about the optimization process?
I also noticed that in the final stage, the model optimized with the first two datasets (100 and 200 images) was split into 2 or 3 contexts, while the one optimized with 1000 images — the one that fails — was split into 6 contexts. Could this be related?
Why More Calibration Images Can Sometimes Hurt Accuracy
Optimization Level Depends on Dataset Quality, Not Just Size
Hailo’s optimize() API enables more aggressive quantization strategies at higher optimization_level settings (e.g., levels 2 and 4). These levels expect a dataset of at least 1024 diverse, well-prepared images.
If you used ~1000 images but didn’t explicitly set a higher optimization_level, those extra samples may not have been fully utilized.
Worse, if optimization_level=2 or higher was used, but the dataset had issues (e.g., not representative of inference conditions), the optimization might miscalibrate and reduce accuracy.
Overfitting During Calibration
Quantization depends on activation statistics gathered during calibration.
A large but unbalanced or redundant dataset can skew these stats, leading to overfitting — the model performs well on calibration data but poorly during actual inference.
Image Format or Preprocessing Mismatch
If your calibration images don’t match the input preprocessing used at inference (e.g., wrong color space, inconsistent normalization), quantization becomes misaligned, hurting accuracy — especially for sensitive outputs like keypoints.
What You Can Do
Preprocess and Normalize Your Dataset
Make sure all calibration images are uniformly preprocessed to match your inference pipeline (resize, color format, normalization, etc.).
Then use a larger set — e.g., your 1000 images plus 24 handpicked edge cases — and run with:
optimize(..., optimization_level=4)
This takes longer but produces significantly better results when the dataset is well-prepared.
Inspect Optimization Logs in the Hailo Profiler
Look for:
Unusual activation ranges or sudden spikes.
Quantization histograms that look skewed or clipped.
Problematic context boundary placements, especially near layers that affect output structure (e.g., keypoint heads).
Use analyze_noise()
This tool shows you which layers are most affected by quantization errors. It’s especially useful if you’re seeing missing or degraded outputs like vanishing keypoints after optimization.
Thank you.
Do you have any suggestions regarding the optimization process?
I have trained a CNN for keypoint detection of a single person (each image contains only one individual). Should the dataset used for optimization consist exclusively of images containing just the person, or is it acceptable to include background elements, as is typically the case in the validation dataset?
Additionally, since I always use the same camera, the input format is consistent. Should I ensure that all images used for optimization have the same resolution, such as 512x384?
Finally, I understand that in Hailo Compile it is possible to specify the input format. Should I explicitly define it? And if I do, am I required to provide all input images at exactly that resolution?
One last, unrelated question: I annotate keypoints for a single person, but in the validation dataset there are images with not only backgrounds but also multiple people. I believe this might be incorrect—training on single-person images and then validating on multi-person scenes seems inconsistent and could negatively affect evaluation.
Would you agree?
Alternatively, I also tried the three-step flow: hailomz parse, optimize, and compile.
However, when I run hailomz optimize --help, I don’t see any way to provide custom settings for the optimization process.
Here’s the issue:
The original .pt model gives correct outputs, but the resulting .hef file performs very poorly — the keypoints are wrong.
For calibration/fine-tuning, I used the COCO2017 val2017 dataset, which contains both people and background images.
Any suggestions on how to improve the optimization? Or how to pass more precise control parameters during the process?
You’re absolutely right that hailomz optimize --help doesn’t show much for fine-tuning, but there are definitely some ways to get better optimization results and reduce that keypoint degradation you’re seeing when going from .pt to .hef.
The yolov8s_pose.yaml file from hailo_model_zoo/cfg/networks/ contains the following lines (see below).
Could you please explain what additional options are available, where they can be added, and what their functions are?
I would really appreciate a detailed explanation of how to customize or extend this YAML configuration file.
"Note: If problems are encountered with VRAM allocation during stages other than Adaround, it is possible attempt to resolve the issue by disabling the memory growth flag.
To do this, set the following environment variable:
HAILO_SET_MEMORY_GROWTH=false
By doing so, the default memory allocation method for tensorflow GPU will be modified, and the entire VRAM will be allocated and managed internally."
But I found nothing about yaml and flags in both guides.
Yep, you can definitely adjust both the training epochs and dataset size for the AdaRound algorithm through our DFC API or CLI. By default, we set epochs to 320 and dataset_size to 1024, but those are completely customizable.
Python API approach
If you’re using the Python API, just pass your values into the post_quantization_optimization call. Say you want to run 100 epochs with 256 samples:
from hailo_sdk_client import ClientRunner
# ... your usual setup ...
runner.post_quantization_optimization(
adaround,
policy='enabled',
epochs=100, # instead of default 320
dataset_size=256 # instead of default 1024
)