Dynamic Resolution Scaling

La mise à l’échelle dynamique de la résolution (DRS) est une technique qui ajuste, image par image, la résolution à laquelle un système traite chaque image afin de maintenir le temps de traitement par image dans une limite fixe. Lorsque le traitement d’une scène devient coûteux, le moteur de rendu ou le modèle traite moins de pixels ; lorsqu’il dispose de marge, il augmente à nouveau la résolution, puis la sortie est généralement agrandie jusqu’à une taille d’affichage constante. Les jeux vidéo l’ont popularisée pour maintenir une fréquence d’images stable sur les consoles et les PC. Le même principe s’applique à l’inférence en temps réel, où un modèle de vision par ordinateur peut réduire la taille de son entrée pour respecter un budget de latence sur du matériel très sollicité ou soumis à une limitation thermique.

Fonctionnement de la mise à l’échelle dynamique de la résolution#

La DRS est une boucle de rétroaction. À chaque image, le système mesure le temps de traitement des dernières images sur le GPU, compare ce temps au budget et choisit une échelle de résolution pour l’image suivante, dans des limites fixes :

L’écart entre « dépassement » et « largement en dessous » évite que la résolution oscille entre deux niveaux. Dans Unreal Engine, par exemple, le budget par défaut est de 33,3 ms par image, soit 30 images par seconde, et le pourcentage de résolution à l’écran varie entre 50 % et 100 % de la résolution de sortie sur chaque axe. Le réglage le plus économique effectue donc le rendu d’un quart des pixels.

L’étape de mise à l’échelle détermine la perte de qualité due à la résolution inférieure. Une mise à l’échelle spatiale simple rend l’image floue. Les jeux modernes associent donc la DRS à des algorithmes d’agrandissement appris ou temporels tels que NVIDIA DLSS, AMD FSR, Intel XeSS et PlayStation Spectral Super Resolution de Sony, qui combinent les images précédentes et, dans la plupart des versions actuelles, l’apprentissage profond pour reconstruire les détails. Cette reconstruction relève de la super-résolution et permet à un jeu d’effectuer le rendu bien en dessous de sa résolution de sortie, avec peu de perte visible.

Résolution dynamique en IA visuelle#

Pour un réseau neuronal convolutif, le coût de calcul et la latence d’inférence augmentent à peu près en proportion du nombre de pixels d’entrée. Réduire de moitié la taille d’entrée, à 320 pixels, ramène donc les FLOPs d’un modèle de 640 pixels à environ un quart. Un contrôleur peut ainsi échanger de la résolution contre de la vitesse lorsqu’un appareil d’IA en périphérie, tel qu’un NVIDIA Jetson, chauffe et réduit sa fréquence d’horloge, lorsqu’un serveur prend en charge davantage de flux de caméras ou lorsqu’un drone a besoin de ressources de calcul supplémentaires pour la navigation. Le compromis porte sur la précision pour les objets petits et éloignés, qui occupent trop peu de pixels à basse résolution ; les systèmes de détection d’objets imposent donc une taille d’entrée minimale.

Ultralytics YOLO26 prend directement en charge cette fonctionnalité en mode prédiction : un modèle PyTorch accepte une valeur imgsz différente à chaque appel sans être rechargé, redimensionne le côté le plus long de chaque image à imgsz et ne complète le côté le plus court que jusqu’au multiple suivant de son pas de 32 pixels. Les modèles exportés dans des formats à taille statique conservent la taille avec laquelle ils ont été exportés, sauf si dynamic=True a été défini. Un contrôleur simple parcourt les tailles autorisées en fonction du temps d’inférence mesuré :

import cv2
from ultralytics import YOLO

model = YOLO("yolo26n.pt")
cap = cv2.VideoCapture("https://github.com/ultralytics/assets/releases/download/v0.0.0/decelera_portrait_min.mov")
sizes = [320, 416, 512, 640]  # tailles d’entrée autorisées, multiples du pas de 32 pixels
level, budget_ms = len(sizes) - 1, 15.0  # démarrer en taille maximale avec un budget d’inférence de 15 ms
frames_at = dict.fromkeys(sizes, 0)

while True:
    ok, frame = cap.read()
    if not ok:
        break
    result = model(frame, imgsz=sizes[level], verbose=False)[0]
    frames_at[sizes[level]] += 1
    # Réduire la taille lorsque le budget est dépassé, et ne l’augmenter à nouveau que lorsqu’on est largement en dessous, afin d’éviter les oscillations
    if result.speed["inference"] > budget_ms and level > 0:
        level -= 1
    elif result.speed["inference"] < 0.6 * budget_ms and level < len(sizes) - 1:
        level += 1

print("Frames processed at each input size:", frames_at)

L’affichage compte les images traitées à chaque taille ; le matériel plus lent traite une plus grande partie de la vidéo aux tailles inférieures.

Termes associés#

• Super-résolution : reconstruit une image à haute résolution à partir d’une image de résolution inférieure et constitue souvent la seconde moitié d’un pipeline DRS.
• Diffusion en continu à débit binaire adaptatif : ajuste la qualité vidéo à la bande passante du réseau plutôt qu’au temps de calcul.
• Ombrage à taux variable : réduit le niveau de détail de l’ombrage dans certaines régions d’une image au lieu de redimensionner l’image entière.
• Entraînement à plusieurs échelles : entraîne un modèle avec des tailles d’entrée variables afin qu’il reste précis lorsque la résolution d’inférence change.
• Résolution dynamique native dans les modèles vision-langage : encode chaque image à sa propre résolution sous la forme d’un nombre variable de jetons pour préserver les détails, comme le fait Qwen2-VL d’Alibaba, qui nomme sa variante Naive Dynamic Resolution.