Skip to main content

Extraction de texte (Qwen-OCR)

Qwen-OCR est un modèle de compréhension visuelle conçu pour extraire du texte et des données structurées à partir d'images : documents numérisés, tableaux, reçus, etc. Il prend en charge plusieurs langues et gère des tâches OCR avancées telles que l'extraction d'informations, l'analyse de tableaux, la reconnaissance de formules mathématiques et le traitement de documents.

Essai en ligne : Accédez à la console Alibaba Cloud Model Studio, sélectionnez la région dans le coin supérieur droit, puis ouvrez la page vision et choisissez Qwen OCR.

Exemples

Image d'entréeRésultat de la reconnaissance
Reconnaissance multilingueimageINTERNATIONALMOTHER LANGUAGEDAYПривет!你好!Bonjour!Merhaba!Ciao!Hello!Ola!בר מולדSalam!
Reconnaissance d'images inclinéesimageProduct IntroductionImported fiber filaments from South Korea.6941990612023Item No.: 2023
Localisation du texteimg_1
La tâche de reconnaissance haute précision permet la localisation du texte.
Visualisation de la localisationimg_1_location
Consultez la FAQ pour savoir comment tracer le cadre englobant de chaque ligne de texte sur l'image originale.

Sélection du modèle

Qwen-OCR propose les modèles suivants. Choisissez celui qui correspond le mieux à vos besoins métier :
  • Qwen3.5-OCR : Fondé sur l'architecture Qwen3.5, ce modèle bénéficie d'améliorations majeures en matière d'analyse de documents, de localisation de texte et d'extraction d'informations clés. Il prend en charge les conversations multi-tours ainsi que l'analyse de documents PDF. L'extraction des données issues de documents officiels (cartes d'identité, permis de conduire, etc.) a été considérablement optimisée. Pour consulter la liste des types de documents pris en charge, reportez-vous à la section Types de certificats et de documents pris en charge. Ce modèle est disponible sous l'identifiant qwen3.5-ocr.
  • Qwen-VL-OCR : Basé sur l'architecture Qwen3-VL. Il intègre nativement diverses fonctionnalités : analyse de documents, localisation de texte (reconnaissance haute précision), extraction d'informations, analyse de tableaux, reconnaissance de formules, reconnaissance de texte générique et reconnaissance multilingue. Il assure également la correction automatique de la rotation des images. Plusieurs versions sont disponibles : qwen-vl-ocr (stable) (dernière version), qwen-vl-ocr-2025-11-20.
  • Versions antérieures (non recommandées) : Ces versions présentent des fonctionnalités et des performances inférieures aux modèles récents. Nous vous conseillons de migrer vers qwen3.5-ocr. Cette catégorie inclut les modèles qwen-vl-ocr-2024-10-28.
Pour les modèles qwen-vl-ocr, and la valeur par défaut du paramètre max_tokens` (longueur maximale de sortie) est fixée à 4096. Si vous souhaitez augmenter cette limite entre 4097 et 8192 tokens, contactez votre responsable commercial en précisant les informations suivantes : votre ID de compte Alibaba Cloud, le type d'images traitées (documents, e-commerce, contrats, etc.), le nom du modèle, le débit estimé en requêtes par seconde (QPS) ainsi que le volume quotidien total de requêtes, et enfin le pourcentage de requêtes dont la sortie dépasse 4096 tokens.
Expérience en ligne : Rendez-vous sur la console Model Studio, sélectionnez la région cible dans le coin supérieur droit, puis accédez à la section Vision Models pour tester les modèles Qwen-OCR.

Prérequis

  • Créez une clé API et définissez-la comme variable d'environnement.
  • Si vous utilisez le SDK OpenAI ou le SDK DashScope, installez la dernière version du SDK. Versions minimales requises : DashScope Python SDK 1.22.2, Java SDK 2.21.8.
    • SDK DashScope
      • Avantages : Accès complet aux fonctionnalités avancées (correction de rotation d'image, tâches OCR intégrées) via une API simple.
      • Cas d'usage idéal : Projets nécessitant l'ensemble des fonctionnalités disponibles.
    • SDK compatible OpenAI
      • Avantages : Remplacement direct des intégrations existantes basées sur le SDK OpenAI.
      • Limitations : Les fonctionnalités avancées, telles que la correction de rotation d'image et les tâches OCR intégrées, ne sont pas directement exposées sous forme de paramètres. Vous pouvez toutefois les simuler en adaptant vos prompts et en analysant la sortie générée.
      • Cas d'usage idéal : Projets utilisant déjà OpenAI et n'ayant pas besoin des fonctionnalités exclusives à DashScope.

Prise en main

L'exemple suivant extrait des champs structurés à partir d'une image de billet de train (URL) et retourne les résultats au format JSON. Pour les fichiers locaux, consultez la section Comment transmettre un fichier local. Pour connaître les contraintes d'entrée, reportez-vous aux Limitations relatives aux images.
  • OpenAI compatible-Chat
  • OpenAI compatible-Response
  • DashScope
Python
from openai import OpenAI
import os

PROMPT_TICKET_EXTRACTION = """
Please extract the invoice number, train number, departure station, destination station, departure date and time, seat number, seat type, ticket price, ID card number, and passenger name from the train ticket image.
Extract the key information accurately. Do not omit information or fabricate false information. Replace any single character that is blurry or obscured by glare with a question mark (?).
Return the data in JSON format: {'Invoice Number': 'xxx', 'Train Number': 'xxx', 'Departure Station': 'xxx', 'Destination Station': 'xxx', 'Departure Date and Time': 'xxx', 'Seat Number': 'xxx', 'Seat Type': 'xxx', 'Ticket Price': 'xxx', 'ID Card Number': 'xxx', 'Passenger Name': 'xxx'}
"""

try:
    client = OpenAI(
        # API keys are region-specific. To get an API key, see https://www.alibabacloud.com/help/en/model-studio/get-api-key
        # If you have not configured an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
    )
    completion = client.chat.completions.create(
        model="qwen-vl-ocr-2025-11-20",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {"url":"https://img.alicdn.com/imgextra/i2/O1CN01ktT8451iQutqReELT_!!6000000004408-0-tps-689-487.jpg"},
                        # The minimum pixel threshold for the input image. If the image is smaller than this value, it is scaled up until the total pixels exceed min_pixels.
                        "min_pixels": 32 * 32 * 3,
                        # The maximum pixel threshold for the input image. If the image is larger than this value, it is scaled down until the total pixels are below max_pixels.
                        "max_pixels": 32 * 32 * 8192
                    },
                    # The model supports passing a prompt in the text field. If no prompt is passed, the default prompt is used: Please output only the text content from the image without any additional descriptions or formatting.
                    {"type": "text",
                     "text": PROMPT_TICKET_EXTRACTION}
                ]
            }
        ])
    print(completion.choices[0].message.content)
except Exception as e:
    print(f"Error message: {e}")
{
  "choices": [{
    "message": {
      "content": "```json\n{\n    \"Invoice Number\": \"24329116804000\",\n    \"Train Number\": \"G1948\",\n    \"Departure Station\": \"Nanjing South Station\",\n    \"Destination Station\": \"Zhengzhou East Station\",\n    \"Departure Date and Time\": \"2024-11-14 11:46\",\n    \"Seat Number\": \"Car 04, Seat 12A\",\n    \"Seat Type\": \"Second Class\",\n    \"Ticket Price\": \"¥337.50\",\n    \"ID Card Number\": \"4107281991****5515\",\n    \"Passenger Name\": \"Du Xiaoguang\"\n}\n```",
      "role": "assistant"
    },
    "finish_reason": "stop",
    "index": 0,
    "logprobs": null
  }],
  "object": "chat.completion",
  "usage": {
    "prompt_tokens": 606,
    "completion_tokens": 159,
    "total_tokens": 765
  },
  "created": 1742528311,
  "system_fingerprint": null,
  "model": "qwen-vl-ocr",
  "id": "chatcmpl-20e5d9ed-e8a3-947d-bebb-c47ef1378598"
}

Appeler des tâches intégrées

Les modèles (à l'exception de qwen-vl-ocr-2024-10-28) incluent des tâches intégrées pour les scénarios OCR courants. Comment appeler une tâche intégrée :
  • SDK DashScope : Définissez le paramètre ocr_options pour invoquer les tâches intégrées. À partir de qwen3.5-ocr, ces tâches fonctionnent conjointement avec votre Prompt personnalisé (elles ne le remplacent plus) et leurs résultats sont renvoyés dans le champ ocr_result. Les modèles antérieurs utilisent un Prompt interne fixe.
  • SDK compatible OpenAI : Transmettez manuellement le Prompt spécifique à la tâche dans votre message.
Chaque tâche possède une valeur task, un Prompt fixe, un format de sortie ainsi qu'un exemple de résultat :

Instructions

  • Reconnaissance haute précision
  • Extraction d'informations
  • Analyse de tableaux
  • Analyse de documents
  • Reconnaissance de formules
  • Reconnaissance générale de texte
  • Reconnaissance multilingue
Pour la reconnaissance haute précision, utilisez des versions de modèle ultérieures à qwen-vl-ocr-2025-11-20 ou la version la plus récente (recommandé). Fonctionnalités :
  • Reconnaît et extrait le contenu textuel.
  • Détecte la position du texte en localisant les lignes de texte et en retournant leurs coordonnées.
Pour tracer des cadres englobants sur l'image d'origine à partir des coordonnées retournées, consultez la FAQ .
Valeur de taskPrompt spécifiéFormat de sortie et exemple
advanced_recognitionLocalise toutes les lignes de texte et retourne les coordonnées du rectangle rotatif ([cx, cy, width, height, angle]).
  • Format : texte brut ou objet JSON récupérable directement depuis le champ ocr_result.
  • Exemple :
    {
      "output": {
        "choices": [
          {
            "message": {
              "content": [
                {
                  "ocr_result": {
                    "words_info": [
                      {
                        "location": [331, 139, 465, 139, 465, 166, 331, 166],
                        "rotate_rect": [398,153,134,27,90],
                        "text": "Magsafe"
                      },
                      {
                        "location": [411, 86, 411, 220, 384, 220, 384, 86],
                        "rotate_rect": [680,250,40,167,90],
                        "text": "金盾系列"
                      },
    
    • text : contenu textuel de chaque ligne.
    • location :
      • Valeur d'exemple : [x1, y1, x2, y2, x3, y3, x4, y4]
      • Signification : coordonnées absolues des quatre sommets du cadre de texte. Le coin supérieur gauche de l'image d'origine sert d'origine (0,0). L'ordre des sommets est fixe : haut-gauche → haut-droite → bas-droite → bas-gauche.
    • rotate_rect :
      • Valeur d'exemple : [center_x, center_y, width, height, angle]
      • Signification : représentation alternative du cadre de texte, où center_x et center_y sont les coordonnées du centroïde du cadre, width correspond à la largeur, height à la hauteur, et angle à l'angle de rotation du cadre par rapport à l'horizontale. La valeur se situe dans l'intervalle [-90, 90].
python
import os
import dashscope

# Replace {WorkspaceId} with your workspace ID. URLs vary by region.
# If you use a model in the China (Beijing) region, change the base_url to https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1.
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

messages = [{
            "role": "user",
            "content": [{
                "image": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241108/ctdzex/biaozhun.jpg",
                # The minimum pixel threshold for the input image. If the image is smaller than this value, it is scaled up until the total pixels are greater than min_pixels.
                "min_pixels": 32 * 32 * 3,
                # The maximum pixel threshold for the input image. If the image is larger than this value, it is scaled down until the total pixels are less than max_pixels.
                "max_pixels": 32 * 32 * 8192,
                # Specifies whether to enable automatic image rotation.
                "enable_rotate": False}]
            }]

response = dashscope.MultiModalConversation.call(
    # If you have not configured an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model='qwen-vl-ocr-2025-11-20',
    messages=messages,
    # Set the built-in task to high-precision recognition.
    ocr_options={"task": "advanced_recognition"}
)
# The high-precision recognition task returns the result as plain text.
print(response["output"]["choices"][0]["message"].content[0]["text"])
{
  "output":{
    "choices":[
      {
        "finish_reason":"stop",
        "message":{
          "role":"assistant",
          "content":[
            {
              "text":"```json\n[{\"pos_list\": [{\"rotate_rect\": [740, 374, 599, 1459, 90]}]}```",
              "ocr_result":{
                "words_info":[
                  {
                    "rotate_rect":[150,80,49,197,-89],
                    "location":[52,54,250,57,249,106,52,103],
                    "text":"Audience"
                  },
                  {
                    "rotate_rect":[724,171,34,1346,-89],
                    "location":[51,146,1397,159,1397,194,51,181],
                    "text":"If you are a system administrator in a Linux environment, learning to write shell scripts will be very beneficial. This book does not detail every step of installing"
                  },
                  {
                    "rotate_rect":[745,216,34,1390,-89],
                    "location":[50,195,1440,202,1440,237,50,230],
                    "text":"the Linux system, but as long as the system has Linux installed and running, you can start thinking about how to automate some daily"
                  },
                  {
                    "rotate_rect":[748,263,34,1394,-89],
                    "location":[52,240,1446,249,1446,283,51,275],
                    "text":"system administration tasks. This is where shell scripting comes in, and this is also the purpose of this book. This book will"
                  },
                  {
                    "rotate_rect":[749,308,34,1395,-89],
                    "location":[51,285,1446,296,1446,331,51,319],
                    "text":"demonstrate how to use shell scripts to automate system administration tasks, from monitoring system statistics and data files to for your boss"
                  },
                  {
                    "rotate_rect":[123,354,33,146,-89],
                    "location":[50,337,197,338,197,372,50,370],
                    "text":"generating reports."
                  },
                  {
                    "rotate_rect":[751,432,34,1402,-89],
                    "location":[51,407,1453,420,1453,454,51,441],
                    "text":"If you are a home Linux enthusiast, you can also benefit from this book. Nowadays, users can easily get lost in a graphical environment built from many stacked components."
                  },
                  {
                    "rotate_rect":[755,477,31,1404,-89],
                    "location":[54,458,1458,463,1458,495,54,490],
                    "text":"Most desktop Linux distributions try to hide the internal details of the system from general users. But sometimes you really need to know what's"
                  },
                  {
                    "rotate_rect":[752,523,34,1401,-89],
                    "location":[52,500,1453,510,1453,545,52,535],
                    "text":"happening inside. This book will show you how to start the Linux command line and what to do next. Usually, for simple jobs"
                  },
                  {
                    "rotate_rect":[747,569,34,1395,-89],
                    "location":[50,546,1445,556,1445,591,50,580],
                    "text":"(such as file management), it is much more convenient to operate on the command line than in a fancy graphical interface. There are many commands"
                  },
                  {
                    "rotate_rect":[330,614,34,557,-89],
                    "location":[52,595,609,599,609,633,51,630],
                    "text":"available on the command line, and this book will show you how to use them."
                  }
                ]
              }
            }
          ]
        }
      }
    ]
  },
  "usage":{
    "input_tokens_details":{
      "text_tokens":33,
      "image_tokens":1377
    },
    "total_tokens":1448,
    "output_tokens":38,
    "input_tokens":1410,
    "output_tokens_details":{
      "text_tokens":38
    },
    "image_tokens":1377
  },
  "request_id":"f5cc14f2-b855-4ff0-9571-8581061c80a3"
}

Analyse de documents PDF

qwen3.5-ocr permet de transmettre directement des fichiers PDF via l'API Response pour l'analyse de documents, sans qu'il soit nécessaire de découper manuellement le PDF en images. La longueur de sortie n'est pas limitée par la capacité maximale du modèle, ce qui permet d'analyser intégralement des documents volumineux. Seule l'API Response est prise en charge ; l'API Chat ne l'est pas. Limites des fichiers PDF : taille inférieure à 100 Mo. Le nombre maximal de pages dépend de task dans ocr_options : jusqu'à 50 pages lorsque task est défini sur document_parsing, et jusqu'à 10 pages lorsque task n'est pas défini ou est défini sur une autre tâche. Les exemples suivants utilisent l'API Response pour transmettre des fichiers PDF afin d'effectuer une analyse de documents.
Python
import os
from openai import OpenAI

client = OpenAI(
    # If you have not configured an environment variable, replace the following line with your API key: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # The URL below is for the China (Beijing) region. Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
    base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
)

response = client.responses.create(
    model="qwen3.5-ocr",
    input=[{
        "role": "user",
        "content": [{
            "type": "input_file",
            "file_url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260616/qmycjl/1506.02640v5.pdf"
        }]
    }],
    extra_body={
        "ocr_options": {"task": "document_parsing"}
    }
)

# Get the built-in task result
print(response.output[0].content[0].ocr_result)
Pour les modèles antérieurs ( qwen-vl-ocr-2025-11-20 et versions précédentes) qui ne prennent pas en charge l'API Response, utilisez une bibliothèque de traitement d'images telle que Python avec pdf2image pour convertir chaque page du PDF en image, puis appliquez la méthode Entrée multi-images pour une reconnaissance page par page.
Pour plus d'informations sur l'utilisation de l'API Responses d'OpenAI (comme la récupération et la gestion des réponses terminées du modèle), consultez Compatibilité OpenAI - Responses .

Transmettre un fichier local (encodage Base64 ou chemin de fichier)

Téléversez des fichiers locaux à l'aide d'un encodage Base64 ou d'un chemin de fichier direct. Choisissez la méthode en fonction de la taille du fichier et du type de SDK — voir Comment choisir une méthode de téléversement de fichier. Les deux méthodes doivent respecter les exigences décrites dans Limites des images.
  • Utiliser l'encodage Base64
  • Utiliser le chemin de fichier
Convertissez le fichier en une chaîne encodée en Base64, puis transmettez-la au modèle. Cette méthode convient aux SDK OpenAI et DashScope ainsi qu'aux requêtes HTTP.
  1. Encodez le fichier : convertissez l'image locale en une chaîne encodée en Base64.
    # Encoding function: Converts a local file to a Base64-encoded string.
    def encode_image(image_path):
        with open(image_path, "rb") as image_file:
            return base64.b64encode(image_file.read()).decode("utf-8")
    
    # Replace xxx/eagle.png with the absolute path of your local image.
    base64_image = encode_image("xxx/eagle.png")
    
  2. Construisez une Data URL selon le format suivant : data:[MIME_type];base64,{base64_image}.
    1. Remplacez MIME_type par le type de média réel. Assurez-vous que ce type correspond à la valeur MIME Type indiquée dans le tableau Limites des images, par exemple image/jpeg ou image/png.
    2. base64_image correspond à la chaîne encodée en Base64 générée à l'étape précédente.
  3. Appelez le modèle : transmettez la Data URL à l'aide du paramètre image ou image_url pour appeler le modèle.
  • Transmettre un chemin de fichier
  • Transmettre une chaîne encodée en Base64
La transmission d'un chemin de fichier est uniquement prise en charge pour les appels effectués avec les SDK Python et Java de DashScope. Cette méthode n'est pas compatible avec les appels HTTP DashScope ni les méthodes compatibles OpenAI.
Python
import os
import dashscope

# Replace {WorkspaceId} with your workspace ID. URLs vary by region.
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

# Replace xxx/test.jpg with the absolute path of your local image.
local_path = "xxx/test.jpg"
image_path = f"file://{local_path}"
messages = [
    {
        "role": "user",
        "content": [
            {
                "image": image_path,
                # The minimum pixel threshold for the input image. If the image has fewer pixels than this value, the image is scaled up until the total number of pixels is greater than min_pixels.
                "min_pixels": 32 * 32 * 3,
                # The maximum pixel threshold for the input image. If the image has more pixels than this value, the image is scaled down until the total number of pixels is less than max_pixels.
                "max_pixels": 32 * 32 * 8192,
            },
            # If no built-in task is set for the model, you can pass a prompt in the text field. If you do not pass a prompt, the default prompt is used: Please output only the text content from the image without any additional descriptions or formatting.
            {
                "text": "Extract the invoice number, train number, departure station, destination station, departure date and time, seat number, seat type, ticket price, ID card number, and passenger name from the train ticket image. Extract the key information accurately. Do not omit or fabricate information. Replace any single character that is blurry or obscured by glare with a question mark (?). Return the data in JSON format: {'invoice_number': 'xxx', 'train_number': 'xxx', 'departure_station': 'xxx', 'destination_station': 'xxx', 'departure_date_and_time': 'xxx', 'seat_number': 'xxx', 'seat_type': 'xxx', 'ticket_price': 'xxx', 'id_card_number': 'xxx', 'passenger_name': 'xxx'}"
            },
        ],
    }
]

response = dashscope.MultiModalConversation.call(
    # API keys vary by region. To obtain an API key, see https://www.alibabacloud.com/help/en/model-studio/get-api-key.
    # If you have not configured an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="qwen-vl-ocr-2025-11-20",
    messages=messages,
)
print(response["output"]["choices"][0]["message"].content[0]["text"])

Autres cas d'utilisation

Limites

Limites relatives aux images

  • Dimensions et rapport d'aspect : La largeur et la hauteur de l'image doivent toutes deux être supérieures à 10 pixels. Le rapport d'aspect ne doit pas dépasser 200:1 ou 1:200.
  • Nombre total de pixels : Le modèle redimensionne automatiquement les images, il n'existe donc pas de limite stricte quant au nombre total de pixels. Toutefois, une image ne peut pas excéder 15,68 millions de pixels.
  • Formats d'image pris en charge
    • Pour les images dont la résolution est inférieure à la 4K (3840x2160), les formats suivants sont pris en charge :

      Format d'image

      Extensions courantes

      Type MIME

      BMP

      .bmp

      image/bmp

      JPEG

      .jpe, .jpeg, .jpg

      image/jpeg

      PNG

      .png

      image/png

      TIFF

      .tif, .tiff

      image/tiff

      WEBP

      .webp

      image/webp

      HEIC

      .heic

      image/heic

    • Pour les images dont la résolution est comprise entre 4K(3840x2160) et 8K(7680x4320), seuls les formats JPEG, JPG et PNG sont pris en charge.
  • Taille de l'image :
    • Si vous fournissez une image via une URL publique ou un chemin local : qwen3.5-ocr prend en charge des images jusqu'à 20 MB ; les autres versions acceptent jusqu'à 10 MB.
    • Si vous fournissez les données en encodage Base64, la chaîne encodée ne doit pas dépasser 10 MB.
    Voir aussi : Comment compresser une image ou une vidéo à la taille requise ? .

Limites du modèle

  • Message système : Qwen-OCR utilise un System Message interne fixe et n'accepte pas de message personnalisé. Transmettez toutes les instructions dans le User Message.
  • Conversations multi-tours : À partir de qwen3.5-ocr, les conversations multi-tours sont prises en charge. Vous pouvez ainsi envoyer des messages texte de suivi sans URL d'image. Les versions qwen-vl-ocr-2025-11-20 et antérieures traitent uniquement le message le plus récent et ne conservent pas le contexte.
  • Risque d'hallucination : Le modèle peut produire des hallucinations si le texte d'une image est trop petit ou de faible résolution. Par ailleurs, la précision des réponses aux questions sans rapport avec l'extraction de texte n'est pas garantie.
  • Traitement des fichiers texte :
    • Pour les fichiers contenant des données image, suivez les recommandations de la section Mise en production afin de les transformer en séquence d'images avant le traitement.
    • Pour les fichiers contenant du texte brut ou des données structurées, utilisez Qwen-Long, un modèle capable d'analyser de longs textes.

Types de certificats et de documents pris en charge

La tâche d'extraction d'informations permet d'extraire des données structurées à partir des certificats, reçus et permis suivants.
  • Passeports et documents de voyage : passeport chinois, passeport de Macao, permis de voyage pour les résidents de Hong Kong et de Macao se rendant en Chine continentale, permis de voyage pour les résidents de Taïwan se rendant en Chine continentale, et permis de retour pour les résidents de Hong Kong et de Macao.
  • Documents relatifs aux véhicules et factures de vente : permis de conduire, plaque signalétique du véhicule, certificat de conformité du véhicule, carte grise, facture de vente de véhicule à moteur et facture de vente de véhicule d'occasion.
  • Factures et reçus fiscaux : facture ordinaire TVA (rouleau), facture spéciale à montant fixe, facture générale imprimée par machine, certificat de paiement des impôts et reçu de revenus non fiscaux centraux.
  • Reçus de transport : billet de train à grande vitesse 12306, billet de train, billet de bateau, reçu de péage autoroutier et facture imprimée par machine pour autoroute.
  • Cartes financières et reçus : carte de crédit, lettre de change bancaire électronique, reçu de paiement et carte de sécurité sociale.
  • Licences commerciales et permis : licence commerciale, licence d'exploitation alimentaire, licence de production alimentaire, licence d'exploitation pharmaceutique et licence d'exploitation de dispositifs médicaux.
  • Certificat immobilier : certificat de propriété immobilière.
  • Cartes d'identité internationales : carte d'identité de Hong Kong, de Macao, indonésienne, thaïlandaise, vietnamienne, malaisienne, philippine, indienne, turque, pakistanaise, mexicaine, britannique et américaine.
  • Passeports et permis de conduire internationaux : passeport indien, singapourien, thaïlandais, américain, australien et des Émirats arabes unis, ainsi que les permis de conduire philippin, japonais et américain.

Facturation et limitation du débit

  • Facturation : Qwen-OCR est un modèle multimodal. Le coût total se calcule comme suit : (nombre de tokens d'entrée × prix unitaire d'entrée) + (nombre de tokens de sortie × prix unitaire de sortie). Consultez vos factures ou rechargez votre compte dans la console Expenses and Costs.
    • Calcul des tokens d'image : Utilisez le code suivant pour estimer la consommation de tokens d'image. La facturation réelle repose sur la réponse de l'API.
      Formule : Tokens d'image = (h_bar * w_bar) / token_pixels + 2.
      • h_bar * w_bar représente les dimensions de l'image redimensionnée. Le modèle prétraite l'image en la redimensionnant selon une limite spécifique de pixels. Cette limite dépend de la valeur du paramètre max_pixels.
      • token_pixels correspond à la valeur en pixels par Token.
        • Pour qwen3.5-ocr, qwen-vl-ocr, qwen-vl-ocr-2025-11-20 et cette valeur est fixée à 32*32 (soit 1024).
        • Pour les autres modèles, cette valeur est fixée à 28*28 (soit 784).
      Ce code illustre la logique approximative de redimensionnement d'image utilisée par le modèle. Utilisez-le pour estimer le nombre de tokens d'une image. La facturation effective dépend de la réponse de l'API.
      import math
      from PIL import Image
      
      def smart_resize(image_path, min_pixels, max_pixels):
          """
          Pre-process an image.
      
          Parameters:
              image_path: The path to the image.
          """
          # Open the specified PNG image file.
          image = Image.open(image_path)
      
          # Get the original dimensions of the image.
          height = image.height
          width = image.width
          # Adjust the height to be a multiple of 28 or 32.
          h_bar = round(height / 32) * 32
          # Adjust the width to be a multiple of 28 or 32.
          w_bar = round(width / 32) * 32
      
          # Scale the image to adjust the total number of pixels to be within the range [min_pixels, max_pixels].
          if h_bar * w_bar > max_pixels:
              beta = math.sqrt((height * width) / max_pixels)
              h_bar = math.floor(height / beta / 32) * 32
              w_bar = math.floor(width / beta / 32) * 32
          elif h_bar * w_bar < min_pixels:
              beta = math.sqrt(min_pixels / (height * width))
              h_bar = math.ceil(height * beta / 32) * 32
              w_bar = math.ceil(width * beta / 32) * 32
          return h_bar, w_bar
      
      # Replace xxx/test.png with the path to your local image.
      h_bar, w_bar = smart_resize("xxx/test.png", min_pixels=32 * 32 * 3, max_pixels=8192 * 32 * 32)
      print(f"The scaled image dimensions are: height {h_bar}, width {w_bar}")
      
      # Calculate the number of image tokens: total pixels divided by 32 * 32.
      token = int((h_bar * w_bar) / (32 * 32))
      
      # <|vision_bos|> and <|vision_eos|> are visual markers. Each is counted as 1 token.
      print(f"Total number of image tokens: {token + 2}")
      
  • Limitation du débit : Pour connaître les limites de débit applicables à Qwen-OCR, reportez-vous à la section Limitation du débit.
  • Quota gratuit (Singapour uniquement) : Qwen-OCR offre un quota gratuit d'un million de tokens. Ce quota est valable 90 jours à compter de la date d'activation de Model Studio ou de l'approbation de votre demande d'utilisation du modèle.

Mise en production

  • Prétraitement des images :
    • Veillez à ce que les images d'entrée soient nettes, uniformément éclairées et peu compressées :
      • Stockez et transmettez les images dans un format sans perte (par exemple, PNG) afin d'éviter toute perte d'informations.
      • Pour améliorer la netteté, appliquez des algorithmes de débruitage, tels qu'un filtrage moyen ou médian, pour lisser les images bruitées.
      • Pour corriger un éclairage inégal, utilisez des algorithmes comme l'égalisation adaptative d'histogramme afin d'ajuster la luminosité et le contraste.
    • Images inclinées : Définissez enable_rotate: true dans le SDK DashScope pour corriger la rotation avant la reconnaissance.
    • Images très petites ou très grandes : Utilisez min_pixels et max_pixels pour contrôler le redimensionnement de l'image.
      • min_pixels : Agrandit les petites images pour en améliorer les détails. Conservez la valeur par défaut.
      • max_pixels : Empêche les images trop volumineuses de consommer un nombre excessif de tokens. La valeur par défaut convient à la plupart des cas. Augmentez-la si du texte de petite taille n'est pas détecté, sachant que cela accroît la consommation de tokens.
  • Validation des résultats : Les résultats de reconnaissance du modèle peuvent contenir des erreurs. Pour les opérations métier critiques, mettez en place un processus de révision manuelle ou ajoutez des règles de validation afin de vérifier l'exactitude des sorties du modèle. Par exemple, utilisez la validation de format pour les numéros de carte d'identité et de carte bancaire.
  • Traitement par lots : Pour les charges de travail volumineuses et non temps réel, utilisez l'API Batch afin de traiter les tâches de manière asynchrone à moindre coût.

FAQ

Choisissez la méthode de téléchargement la plus adaptée en fonction du type de SDK, de la taille du fichier et de la stabilité du réseau.

Type

Spécifications

DashScope SDK (Python, Java)

Compatible OpenAI / DashScope HTTP

Image

Supérieure à 7 MB et inférieure à 10 MB

Transmettre le chemin local

Seules les URL publiques sont prises en charge. Utilisez Object Storage Service.

Inférieure à 7 MB

Transmettre le chemin local

Encodage Base64

L'encodage Base64 augmente la taille des données. Le fichier original doit peser moins de 7 MB.
L'utilisation d'un chemin local ou de l'encodage Base64 permet d'éviter les délais d'attente de téléchargement côté serveur et d'améliorer la stabilité.
Une fois que le modèle Qwen-OCR a renvoyé les résultats de localisation de texte, utilisez le code du fichier draw_bbox.py pour tracer les cadres de détection et leurs libellés sur l'image d'origine.

Référence de l'API

Pour consulter les paramètres d'entrée et de sortie de Qwen-OCR, reportez-vous à la Référence de l'API Qwen-OCR.

Codes d'erreur

Si l'appel du modèle échoue et renvoie un message d'erreur, consultez la rubrique Codes d'erreur pour obtenir des solutions.