CU 1

75
34
1 language
license:mit
by
racineai
Image Model
OTHER
New
75 downloads
Early-stage
Try on Hugging FaceAdd to Compare
Edge AI:
Mobile
Laptop
Server
Unknown
Mobile
Laptop
Server
Quick Summary

UI-DETR-1 (Computer Use Agent v1) is a fine-tuned implementation of RF-DETR-M specifically optimized for autonomous computer interaction.

Code Examples

Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Model Usagebash
# Core requirements
pip install torch torchvision opencv-python pillow

# RF-DETR library
pip install rfdetr
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")
Core requirementspython
from rfdetr.detr import RFDETRMedium
import cv2
import numpy as np

# Load the model with your trained weights
model = RFDETRMedium(pretrain_weights="model.pth", resolution=1600)

# Process an image
image = cv2.imread("screenshot.png")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Run detection
detections = model.predict(image_rgb, threshold=0.3)

# Get results
boxes = detections.xyxy  # Bounding boxes
scores = detections.confidence  # Confidence scores

print(f"Detected {len(boxes)} UI elements")

Deploy This Model

Production-ready deployment in minutes

Together.ai

Instant API access to this model

Fastest API

Production-ready inference API. Start free, scale to millions.

Try Free API

Replicate

One-click model deployment

Easiest Setup

Run models in the cloud with simple API. No DevOps required.

Deploy Now

Disclosure: We may earn a commission from these partners. This helps keep LLMYourWay free.