Comment utiliser les LLM Frontier Vision : Qwen3-VL

(VLM) sont des modèles puissants capables de saisir à la fois des images et du texte et de répondre avec du texte. Cela nous permet d’effectuer une extraction d’informations visuelles sur des documents et des images. Dans cet article, je discuterai du nouveau Qwen 3 VL et des puissantes capacités que possèdent les VLM.

Qwen 3 VL est sorti il ​​y a quelques semaines, initialement avec le modèle 235B-A22B, qui est un modèle assez volumineux. Ils ont ensuite sorti le 30B-A3B, et viennent tout juste de sortir les versions denses 4B et 8B. Mon objectif pour cet article est de mettre en évidence les capacités des modèles de langage de vision et de vous informer de leurs capacités à un niveau élevé. J’utiliserai Qwen 3 VL comme exemple spécifique dans cet article, bien qu’il existe de nombreux autres VLM de haute qualité disponibles. Je ne suis en aucun cas affilié à Qwen au moment de la rédaction de cet article.

Pourquoi avons-nous besoin de modèles de langage de vision

Les modèles de langage de vision sont nécessaires car l’alternative consiste à s’appuyer sur l’OCR et à introduire le texte édité par OCR dans un LLM. Cela pose plusieurs problèmes :

• L’OCR n’est pas parfait et le LLM devra faire face à une extraction de texte imparfaite
• Vous perdez les informations contenues dans la position visuelle du texte

Les moteurs OCR traditionnels comme Tesseract jouent depuis longtemps un rôle extrêmement important dans le traitement des documents. L’OCR nous a permis de saisir des images et d’en extraire le texte, permettant ainsi un traitement ultérieur du contenu du document. Cependant, l’OCR traditionnelle est loin d’être parfaite et peut rencontrer des problèmes tels que des textes de petite taille, des images asymétriques, du texte vertical, etc. Si votre résultat OCR est médiocre, vous aurez du mal à effectuer toutes les tâches en aval, que vous utilisiez une expression régulière ou un LLM. L’envoi d’images directement dans les VLM, au lieu de texte OCR dans les LLM, est donc beaucoup plus efficace dans l’utilisation des informations.

La position visuelle du texte est parfois essentielle à la compréhension du sens du texte. Imaginez l’exemple de l’image ci-dessous, où vous avez des cases à cocher soulignant quel texte est pertinent, où certaines cases sont cochées et d’autres non. Vous pourriez alors avoir du texte correspondant à chaque case à cocher, où seul le texte à côté de la case cochée est pertinent. Extraire ces informations à l’aide d’OCR + LLM est un défi, car vous ne pouvez pas savoir à quel texte appartient la case cochée. Cependant, résoudre cette tâche à l’aide de modèles de langage de vision est trivial.

J’ai transmis l’image ci-dessus à Qwen 3 VL, et il a répondu avec la réponse ci-dessous :

Based on the image provided, the documents that are checked off are:

- **Document 1** (marked with an "X")
- **Document 3** (marked with an "X")

**Document 2** is not checked (it is blank).

Comme vous pouvez le constater, Qwen 3 VL a facilement résolu le problème correctement.

---

Une autre raison pour laquelle nous avons besoin des VLM est que nous obtenons également une compréhension vidéo. Comprendre réellement les clips vidéo serait extrêmement difficile avec l’OCR, car de nombreuses informations contenues dans les vidéos ne sont pas affichées avec du texte, mais plutôt directement sous forme d’image. L’OCR n’est donc pas efficace. Cependant, la nouvelle génération de VLM vous permet de saisir des centaines d’images, par exemple représentant une vidéo, vous permettant ainsi d’effectuer des tâches de compréhension vidéo.

Tâches du modèle de langage de vision

Il existe de nombreuses tâches auxquelles vous pouvez appliquer des modèles de langage de vision. Je vais discuter de quelques-unes des tâches les plus pertinentes.

• ROC
• Extraction d’informations

Les données

J’utiliserai l’image ci-dessous comme exemple d’image pour mes tests.

J’utiliserai cette image car c’est un exemple de document réel, très pertinent pour appliquer Qwen 3 VL. De plus, j’ai recadré l’image à sa forme actuelle, afin de pouvoir l’insérer en haute résolution dans Qwen 3 VL sur mon ordinateur local. Le maintien d’une haute résolution est essentiel si vous souhaitez effectuer une OCR sur l’image. J’ai extrait le JPG d’un PDF en utilisant 600 DPI. Normalement, 300 DPI suffisent pour l’OCR, mais j’ai gardé un DPI plus élevé juste pour être sûr, ce qui fonctionne dans cette petite image.

Préparer Qwen 3 VL

J’ai besoin des importations suivantes pour exécuter Qwen 3 VL :

torch
accelerate
pillow
torchvision
git+https://github.com/huggingface/transformers

Vous devez installer Transformers à partir des sources (GitHub), car Qwen 3 VL n’est pas encore disponible dans la dernière version de Transformers.

Le code suivant charge les importations, le modèle et le processeur, et crée une fonction d’inférence :

from transformers import Qwen3VLForConditionalGeneration, AutoProcessor
from PIL import Image
import os
import time

# default: Load the model on the available device(s)
model = Qwen3VLForConditionalGeneration.from_pretrained(
    "Qwen/Qwen3-VL-4B-Instruct", dtype="auto", device_map="auto"
)

processor = AutoProcessor.from_pretrained("Qwen/Qwen3-VL-4B-Instruct")



def _resize_image_if_needed(image_path: str, max_size: int = 1024) -> str:
    """Resize image if needed to a maximum size of max_size. Keep the aspect ratio."""
    img = Image.open(image_path)
    width, height = img.size
    
    if width <= max_size and height <= max_size:
        return image_path
    
    ratio = min(max_size / width, max_size / height)
    new_width = int(width * ratio)
    new_height = int(height * ratio)
    
    img_resized = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
    
    base_name = os.path.splitext(image_path)[0]
    ext = os.path.splitext(image_path)[1]
    resized_path = f"{base_name}_resized{ext}"
    
    img_resized.save(resized_path)
    return resized_path


def _build_messages(system_prompt: str, user_prompt: str, image_paths: list[str] | None = None, max_image_size: int | None = None):
    messages = [
        {"role": "system", "content": [{"type": "text", "text": system_prompt}]}
    ]
    
    user_content = []
    if image_paths:
        if max_image_size is not None:
            processed_paths = [_resize_image_if_needed(path, max_image_size) for path in image_paths]
        else:
            processed_paths = image_paths
        user_content.extend([
            {"type": "image", "min_pixels": 512*32*32, "max_pixels": 2048*32*32, "image": image_path}
            for image_path in processed_paths
        ])
    user_content.append({"type": "text", "text": user_prompt})
    
    messages.append({
        "role": "user",
        "content": user_content,
    })
    
    return messages


def inference(system_prompt: str, user_prompt: str, max_new_tokens: int = 1024, image_paths: list[str] | None = None, max_image_size: int | None = None):
    messages = _build_messages(system_prompt, user_prompt, image_paths, max_image_size)
    
    inputs = processor.apply_chat_template(
        messages,
        tokenize=True,
        add_generation_prompt=True,
        return_dict=True,
        return_tensors="pt"
    )
    inputs = inputs.to(model.device)
    
    start_time = time.time()
    generated_ids = model.generate(**inputs, max_new_tokens=max_new_tokens)
    generated_ids_trimmed = [
        out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
    ]
    output_text = processor.batch_decode(
        generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False
    )
    end_time = time.time()
    print(f"Time taken: {end_time - start_time} seconds")
    
    return output_text[0]

ROC

L’OCR est une tâche pour laquelle la plupart des VLM sont formés. Vous pouvez par exemple lire les rapports techniques des modèles Qwen VL, où ils mentionnent comment les données OCR font partie de l’ensemble d’entraînement. Pour entraîner les VLM à effectuer l’OCR, ils donnent au modèle une série d’images et le texte contenu dans ces images. Le modèle apprend ensuite à extraire le texte des images.

Je vais appliquer l’OCR à l’image avec l’invite ci-dessous, qui est la même invite que l’équipe Qwen utilise pour effectuer l’OCR selon les Livre de recettes Qwen 3 VL.

user_prompt = "Read all the text in the image."

Maintenant, je vais exécuter le modèle. J’ai appelé l’image de test sur laquelle nous travaillons, pour exemple-doc-site-plan-cropped.jpg

system_prompt = """
You are a helpful assistant that can answer questions and help with tasks.
"""

user_prompt = "Read all the text in the image."
max_new_tokens = 1024

image_paths = ["example-doc-site-plan-cropped.jpg"]
output = inference(system_prompt, user_prompt, max_new_tokens, image_paths, max_image_size=1536)
print(output)

Quelles sorties :

Plan- og
bygningsetaten

Dato: 23.01.2014
Bruker: HKN
Målestokk 1:500
Ekvidistanse 1m
Høydegrunnlag: Oslo lokal
Koordinatsystem: EUREF89 - UTM sone 32
© Plan- og bygningsetaten,
Oslo kommune
Originalformat A3

Adresse:
Camilla Colletts vei 15

Gnr/Bnr:
.

Kartet er sammenstilt for:
.

PlotID: / Best.nr.:
27661 /

Deres ref: Camilla Colletts vei 15

Kommentar:
Gjeldende kommunedelplaner:
KDP-BB, KDP-13, KDP-5

Kartutsnittet gjelder vertikalinvå 2.
I tillegg finnes det regulering i
følgende vertikalinvå:
(Hvis blank: Ingen øvrige.)

Det er ikke registrert
naturn mangfold innenfor
Se tegnforklaring på eget ark.

Beskrivelse:
NR:
Dato:
Revidert dato:

Cette sortie est issue de mes tests, tout à fait correcte, couvre tout le texte de l’image et extrait tous les caractères corrects.

Extraction d’informations

Vous pouvez également effectuer une extraction d’informations à l’aide de modèles de langage de vision. Cela peut, par exemple, être utilisé pour extraire des métadonnées importantes à partir d’images. Vous souhaitez généralement également extraire ces métadonnées au format JSON, afin qu’elles soient facilement analysables et puissent être utilisées pour des tâches en aval. Dans cet exemple, j’extrairai :

• Date – 23.01.2024 dans cet exemple
• Adresse – Camilla Colletts voir 15 dans cet exemple
• Gnr (numéro de rue) – qui dans l’image de test est un champ vide
• Målestokk (échelle) – 1:500

J’exécute le code suivant :

user_prompt = """
Extract the following information from the image, and reply in JSON format:
{
    "date": "The date of the document. In format YYYY-MM-DD.",
    "address": "The address mentioned in the document.",
    "gnr": "The street number (Gnr) mentioned in the document.",
    "scale": "The scale (målestokk) mentioned in the document.",
}
If you cannot find the information, reply with None. The return object must be a valid JSON object. Reply only the JSON object, no other text.
"""
max_new_tokens = 1024

image_paths = ["example-doc-site-plan-cropped.jpg"]
output = inference(system_prompt, user_prompt, max_new_tokens, image_paths, max_image_size=1536)
print(output)

Quelles sorties :

{
    "date": "2014-01-23",
    "address": "Camilla Colletts vei 15",
    "gnr": "15",
    "scale": "1:500"
}

L’objet JSON est dans un format valide et Qwen a réussi à extraire les champs de date, d’adresse et d’échelle. Cependant, Qwen a effectivement renvoyé un message. Au départ, lorsque j’ai vu ce résultat, j’ai supposé qu’il s’agissait d’une hallucination, puisque le champ Gnr de l’image test est vide. Cependant, Qwen a en fait fait l’hypothèse naturelle que le Gnr est disponible dans l’adresse, ce qui est correct dans ce cas.

Pour être sûr de ses capacités à répondre None s’il ne trouve rien, j’ai demandé à Qwen d’extraire le Bnr (numéro de bâtiment), qui n’est pas disponible dans cet exemple. Exécuter le code ci-dessous :

user_prompt = """
Extract the following information from the image, and reply in JSON format:
{
    "date": "The date of the document. In format YYYY-MM-DD.",
    "address": "The address mentioned in the document.",
    "Bnr": "The building number (Bnr) mentioned in the document.",
    "scale": "The scale (målestokk) mentioned in the document.",
}
If you cannot find the information, reply with None. The return object must be a valid JSON object. Reply only the JSON object, no other text.
"""
max_new_tokens = 1024

image_paths = ["example-doc-site-plan-cropped.jpg"]
output = inference(system_prompt, user_prompt, max_new_tokens, image_paths, max_image_size=1536)
print(output)

J’obtiens :

{
    "date": "2014-01-23",
    "address": "Camilla Colletts vei 15",
    "Bnr": None,
    "scale": "1:500"
}

Comme vous pouvez le constater, Qwen parvient à nous informer si des informations ne sont pas présentes dans le document.

Inconvénients des modèles de langage de vision

Je voudrais également noter qu’il existe également certains problèmes avec les modèles de langage de vision. L’image avec laquelle j’ai testé l’OCR et l’extraction d’informations est une image relativement simple. Pour véritablement tester les capacités de Qwen 3, je devrais l’exposer à des tâches plus difficiles, par exemple extraire plus de texte d’un document plus long ou lui faire extraire davantage de champs de métadonnées.

Les principaux inconvénients actuels des VLM, d’après ce que j’ai vu, sont :

• Texte parfois manquant avec OCR
• L’inférence est lente

Le texte manquant dans les VLM lors de l’exécution de l’OCR est quelque chose que j’ai observé à plusieurs reprises. Lorsque cela se produit, le VLM manque généralement une section du document et ignore complètement le texte. Ceci est naturellement très problématique, car cela pourrait manquer du texte essentiel pour les tâches en aval telles que les recherches par mots clés. La raison pour laquelle cela se produit est un sujet complexe qui sort du cadre de cet article, mais c’est un problème dont vous devez être conscient si vous effectuez une OCR avec des VLM.

De plus, les VLM nécessitent beaucoup de puissance de traitement. J’utilise localement sur mon PC, même si j’utilise également un très petit modèle. J’ai commencé à rencontrer des problèmes de mémoire lorsque je voulais simplement traiter une image de dimensions 2048×2048, ce qui est problématique si je souhaite effectuer une extraction de texte à partir de documents plus volumineux. Vous pouvez donc imaginer à quel point il est gourmand en ressources d’appliquer les VLM à :

• Plus d’images à la fois (par exemple, traitement d’un document de 10 pages)
• Traitement de documents de résolutions plus élevées
• Utiliser un VLM plus grand, avec plus de paramètres

Conclusion

Dans cet article, j’ai discuté des VLM, où j’ai commencé par expliquer pourquoi nous avons besoin de VLM, en soulignant comment certaines tâches nécessitent à la fois du texte et la position visuelle du texte. De plus, j’ai mis en évidence certaines tâches que vous pouvez effectuer avec les VLM et comment Qwen 3 VL a pu effectuer ces tâches. Je pense que la modalité de vision sera de plus en plus importante dans les années à venir. Jusqu’à il y a un an, l’accent était presque entièrement mis sur les modèles de texte pur. Cependant, pour obtenir des modèles encore plus puissants, nous devons utiliser la modalité de vision, et c’est là que je pense que les VLM seront extrêmement importants.