DeepSeek-OCR : guide pratique avec 7 exemples concrets

DeepSeek-OCR est un nouveau grand modèle vision-langage qui comprend la structure, parse des tableaux, extrait des graphiques et peut même gérer les mathématiques, les mèmes et plusieurs langues.

Dans ce guide, je mets DeepSeek-OCR à l’épreuve sur des tâches réalistes de bout en bout : des notes manuscrites aux graphiques complexes, en passant par les mèmes et des documents multilingues. Nous verrons :

• Extraction de graphiques et de tableaux
• Analyse de chimie et parsing de formules
• Reconnaissance d’écriture manuscrite
• Équations et sortie Markdown
• OCR pour mèmes et images sociales
• Compréhension de documents multilingues

À la fin, vous verrez où DeepSeek-OCR excelle et où il montre encore ses limites. Si vous explorez l’OCR open source, regardez ces expériences avant de choisir votre pipeline. Je vous recommande aussi notre tutoriel DeepSeek V3.2-Speciale.

Qu’est-ce que DeepSeek-OCR ?

DeepSeek-OCR est un modèle vision-langage ouvert de 3 milliards de paramètres entraîné pour la compréhension de documents. Il s’appuie sur une compression optique du contexte en mappant de grands contextes visuels 2D en jetons de vision compressés, ce qui lui permet de traiter efficacement des documents volumineux.

Parmi ses principales fonctionnalités :

• Lecture de gros documents scannés, reçus, factures, articles de recherche, etc.
• Parsing de tableaux, graphiques et figures géométriques.
• Gestion du multilingue et de l’écriture manuscrite.

Comment fonctionne DeepSeek-OCR ?

DeepSeek-OCR est conçu pour traiter un large éventail d’images de documents, des graphiques et tableaux à l’écriture manuscrite, aux mathématiques et aux textes multilingues. Plutôt que de traiter les images et le texte comme des domaines séparés, il utilise la modalité visuelle comme moteur de compression pour les longs textes, permettant aux grands modèles de langage (LLMs) de traiter bien plus d’informations avec beaucoup moins de jetons. Voyons son architecture et ce qui la distingue :

Le pipeline de bout en bout : encodeur → décodeur

À haut niveau, DeepSeek-OCR se compose de deux grands composants :

• DeepEncoder (tokeniseur & compresseur de vision)
• DeepSeek-3B MoE Decoder (générateur de texte)

Source : DeepSeek-OCR: Contexts Optical Compression

1. Prétraitement de l’image d’entrée : Le pipeline commence par une image de document (contrat scanné, note manuscrite, tableau financier, etc.). Cette image est découpée en une grille de patchs de 16×16 pixels, les plus petites « mots visuels » compris par le modèle.

2. DeepEncoder : DeepEncoder est un moteur de vision multi‑étapes conçu pour équilibrer résolution, mémoire et compression d’information. Il opère en trois étapes principales :

• SAM (Segment Anything Model, 80 M de paramètres) : gère l’attention locale via l’analyse de petits patchs qui se chevauchent pour capturer les détails fins et la mise en page.
• Compresseur convolutionnel (sous‑échantillonnage ×16) : réduit fortement le nombre de jetons visuels en compressant les caractéristiques locales, de sorte que moins de jetons atteignent l’étape coûteuse d’attention globale.
• CLIP ViT : un transformeur de vision (300 M de paramètres) qui applique une attention globale pour comprendre la structure et le contexte d’ensemble du document, jouant le rôle de couche d’embedding pour les jetons compressés.

3. Des jetons de vision vers le texte : Le décodeur MoE compresse les jetons de vision qui sont transmis au décodeur DeepSeek‑3B MoE (Mixture‑of‑Experts) pour une inférence efficace, en activant uniquement les experts les plus pertinents par échantillon afin de réduire le coût de calcul sans sacrifier la précision.

4. Flexibilité pilotée par le prompt : Le système oriente le format de sortie (Markdown, tableaux HTML, formules chimiques SMILES, mises en page multilingues, etc.) simplement en changeant le prompt, comme avec les LLM.

DeepSeek-OCR montre qu’une seule image de document peut être « compressée » en jusqu’à 1/10^e des jetons nécessaires au texte brut, sans perte substantielle de précision. 

Démo DeepSeek OCR : application Gradio

Dans cette section, nous allons configurer une application web Gradio complète pour faire tourner DeepSeek‑OCR directement dans votre navigateur ou sur Google Colab. En quelques étapes, vous pouvez téléverser des images de graphiques, tableaux, notes manuscrites, mèmes, maths, textes multilingues, et obtenir une sortie structurée avec boîtes englobantes.

Étape 1 : prérequis

Avant de commencer, assurez-vous d’avoir les prérequis suivants :

!pip install -q "transformers==4.46.3" "tokenizers==0.20.3" einops addict easydict pillow gradioPropulsé par

La commande ci‑dessus installe toutes les bibliothèques Python requises pour DeepSeek‑OCR et Gradio, y compris des versions compatibles récentes de transformers, tokenizers, le traitement d’images (pillow) et le toolkit UI Gradio. 

Remarque : ce code s’exécute sur un GPU L4 avec RAM élevée sur Google Colab.

Étape 2 : imports

Les dépendances sont installées.  Passons aux imports.

import os, time, torch, gradio as gr
from PIL import Image
from transformers import AutoModel, AutoTokenizer
from datetime import datetime
import random
import stringPropulsé par

Nous importons les modules essentiels pour l’E/S fichiers, l’inférence du modèle (torch), la construction d’UI (gradio), la gestion d’images (PIL) et des utilitaires pour gérer les chemins et des identifiants de runs aléatoires.

Étape 3 : charger le modèle

Une fois les bibliothèques installées, vous pouvez charger le modèle DeepSeek‑OCR depuis Hugging Face. Cependant, l’accès à certains modèles nécessite une authentification avec un jeton d’accès Hugging Face.

Voici comment configurer votre jeton d’accès Hugging Face dans Google Colab :

• Ajouter un secret dans Colab : dans votre notebook Google Colab, cliquez sur l’icône en forme de clé (« Secrets ») dans la barre latérale gauche et sélectionnez « Add a Secret ».
• Créer un jeton sur Hugging Face : connectez‑vous à votre compte Hugging Face, allez dans les paramètres, section « Access Tokens ». Cliquez sur « Create new token », choisissez le rôle approprié (généralement « Read ») et générez votre jeton.
• Copier‑coller le jeton : copiez votre jeton d’accès et collez‑le dans le champ « Add a Secret » de Colab. Votre notebook pourra ainsi accéder en toute sécurité au modèle DeepSeek‑OCR.

Vous pouvez maintenant vous authentifier et charger le modèle !

model_id = "deepseek-ai/DeepSeek-OCR"
tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
if tok.pad_token is None and tok.eos_token is not None:
    tok.pad_token = tok.eos_token
model = AutoModel.from_pretrained(
    model_id,
    trust_remote_code=True,
    use_safetensors=True,
    attn_implementation="eager"
).to(dtype=torch.bfloat16, device="cuda").eval()Propulsé par

Ce code charge le modèle officiel DeepSeek‑OCR et son tokenizer depuis Hugging Face. Il assure ensuite la compatibilité du tokenizer en définissant le jeton de padding, et charge le modèle au format bfloat16.

Étape 4 : fonction utilitaire

Le modèle est prêt ; nous créons maintenant un nouveau répertoire pour chaque sortie afin de garder chaque exécution d’OCR organisée. Le texte extrait, les visualisations de boîtes et les logs sont ainsi stockés sans écraser les précédents résultats.

def new_run_dir(base="/content/runs"):
    os.makedirs(base, exist_ok=True)
    ts = datetime.now().strftime("%Y%m%d-%H%M%S")
    rid = ''.join(random.choices(string.ascii_lowercase + string.digits, k=5))
    path = os.path.join(base, f"run_{ts}_{rid}")
    os.makedirs(path)
    return pathPropulsé par

La fonction new_run_dir crée un répertoire de sortie unique pour chaque traitement, basé sur un horodatage et un suffixe aléatoire. Elle évite les écrasements et facilite l’inspection ou le débogage.

Étape 5 : gestionnaire OCR

Cette étape constitue le cœur de l’application Gradio DeepSeek‑OCR. On convertit d’abord l’image téléversée au bon format et on la redimensionne si elle est trop lourde. À chaque exécution, tous les résultats sont enregistrés dans un nouveau dossier.

def gr_ocr(image, mode, custom_prompt, base_size, image_size, crop_mode):
    img = image.convert("RGB")
    if max(img.size) > 2000:
        s = 2000 / max(img.size)
        img = img.resize((int(img.width*s), int(img.height*s)), Image.LANCZOS)
    run_dir = new_run_dir()
    img_path_proc = os.path.join(run_dir, "input.png")
    img.save(img_path_proc, optimize=True)
    if mode == "Custom Prompt" and custom_prompt.strip():
        prompt = custom_prompt.strip()
    else:
        prompt = DEMO_MODES[mode]["prompt"]
    t0 = time.time()
    try:
        with torch.inference_mode():
            _ = model.infer(
                tok,
                prompt=prompt,
                image_file=img_path_proc,
                output_path=run_dir,
                base_size=base_size,
                image_size=image_size,
                crop_mode=crop_mode,
                save_results=True,
                test_compress=True
            )
    except ZeroDivisionError:
        print(" [Patched] Division by zero in compression ratio (valid_img_tokens==0). Ignored.")
    dt = time.time() - t0
    result_file = os.path.join(run_dir, "result.mmd")
    if not os.path.exists(result_file):
        result_file = os.path.join(run_dir, "result.txt")
    result = "[No text extracted]"
    if os.path.exists(result_file):
        with open(result_file, "r", encoding="utf-8") as f:
            result = f.read().strip() or "[No text extracted]"
    boxed_path = os.path.join(run_dir, "result_with_boxes.jpg")
    boxed_img = Image.open(boxed_path) if os.path.exists(boxed_path) else None
    stats = f"""
**{dt:.1f}s** | Image: {img.size[0]}×{img.size[1]} px  
**Output directory:** {run_dir}  
"""
    return result, stats, boxed_imgPropulsé par

La fonction gr_ocr encapsule le prétraitement, l’inférence et le post‑traitement de l’application Gradio DeepSeek‑OCR. Elle effectue :

• Standardisation et prétraitement de l’image : conversion en RGB pour compatibilité modèle. Si l’image dépasse 2000 px, redimensionnement proportionnel pour éviter un dépassement mémoire GPU.
• Gestion des répertoires de run : chaque exécution est isolée dans un dossier unique, garantissant traçabilité, débogage et reproductibilité.
• Inférence efficace du modèle : appel du modèle dans un contexte torch.inference_mode() pour éviter les gradients, réduire la mémoire et accélérer l’inférence.
• Gestion des cas limites et erreurs : prise en charge d’exceptions comme ZeroDivisionError lors de cas rares de compression, sans perturber l’expérience utilisateur.
• Agrégation et visualisation des résultats : chargement du texte extrait et de l’image annotée avec boîtes englobantes pour inspection rapide.
• Intégration UI : renvoi d’un triplet (sortie OCR, statistiques, image annotée) pour intégration fluide à l’interface Gradio.

Passons à l’interface interactive pour voir DeepSeek‑OCR en action.

Étape 6 : UI Gradio

Dernière étape : définir une interface Gradio interactive pour DeepSeek‑OCR, afin de téléverser des images, choisir différents modes d’extraction OCR, ajuster des réglages avancés et visualiser les sorties dans une même UI web.

DEMO_MODES = {
    "Document ➔ Markdown": {
        "prompt": "<image>\n<|grounding|>Convert the document to markdown.",
        "desc": "Extracts full document text as Markdown, preserving structure (headings, tables, lists, etc.).",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Chart Deep Parsing": {
        "prompt": "<image>\nParse all charts and tables. Extract data as HTML tables.",
        "desc": "Extracts tabular/chart data into HTML tables.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Chemical Formula Recognition": {
        "prompt": "<image>\nExtract all chemical formulas and SMILES.",
        "desc": "Extracts chemical structures and formulae.",
        "base_size": 1024, "image_size": 768, "crop_mode": False
    },
    "Geometry Parsing": {
        "prompt": "<image>\nExtract all geometric figures and their measurements.",
        "desc": "Parses diagrams and extracts geometric data.",
        "base_size": 1024, "image_size": 768, "crop_mode": False
    },
    "Plain Text Extraction": {
        "prompt": "<image>\nFree OCR.",
        "desc": "Fast, plain text OCR of the image.",
        "base_size": 768, "image_size": 512, "crop_mode": False
    },
    "Multilingual Document": {
        "prompt": "<image>\n<|grounding|>Extract text. Preserve all languages and structure.",
        "desc": "Extracts multi-language content, preserves structure.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    },
    "Custom Prompt": {
        "prompt": "",
        "desc": "Provide your own custom prompt for flexible OCR or parsing.",
        "base_size": 1024, "image_size": 640, "crop_mode": False
    }
}
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("""
    <div style=\"text-align:center;\">
        <h1>DeepSeek-OCR Demo</h1>
    </div>
    """)
    with gr.Row():
        with gr.Column():
            gr.Markdown("### Input")
            image_input = gr.Image(type="pil", label="Upload Document/Image", height=350)
            gr.Markdown("#### Demo Modes (From Paper)")
            mode = gr.Radio(
                choices=list(DEMO_MODES.keys()), value="Document to Markdown", label="Select Capability to Test"
            )
            desc = gr.Markdown(DEMO_MODES["Document to Markdown"]["desc"])
            custom_prompt = gr.Textbox(label="Custom Prompt", visible=False)
            with gr.Accordion("Advanced Settings", open=False):
                base_size = gr.Slider(512, 1280, value=DEMO_MODES["Document to Markdown"]["base_size"], step=64, label="Base Size")
                image_size = gr.Slider(512, 1280, value=DEMO_MODES["Document to Markdown"]["image_size"], step=64, label="Image Size")
                crop_mode = gr.Checkbox(value=DEMO_MODES["Document to Markdown"]["crop_mode"], label="Dynamic Resolution (Crop Mode)")
            process_btn = gr.Button("Process Image", variant="primary")
        with gr.Column():
            gr.Markdown("### Results")
            ocr_output = gr.Textbox(label="Extracted Content", lines=22, show_copy_button=True)
            status_out = gr.Markdown("_Process an image to see stats and output dir_")
            boxed_output = gr.Image(label="Result with Bounding Boxes", type="pil")
    def update_mode(selected):
        d = DEMO_MODES[selected]
        return d["desc"], gr.update(visible=selected=="Custom Prompt"), d["base_size"], d["image_size"], d["crop_mode"]
    mode.change(update_mode, inputs=mode,
                outputs=[desc, custom_prompt, base_size, image_size, crop_mode])
    process_btn.click(
        gr_ocr,
        inputs=[image_input, mode, custom_prompt, base_size, image_size, crop_mode],
        outputs=[ocr_output, status_out, boxed_output]
    )
demo.launch(share=True, debug=True)Propulsé par

Décomposons ce code par sous‑sections :

• Modes démo et prompts : le dictionnaire DEMO_MODES regroupe les principales capacités OCR de DeepSeek‑OCR, telles que « Document to Markdown », « Chart Deep Parsing », « Chemical Formula Recognition », etc. Chaque mode inclut un prompt par défaut, une description et des paramètres recommandés, permettant de changer de tâche d’extraction à la volée.
• Architecture en blocs : l’UI est construite avec l’API Blocks de Gradio. L’interface se divise en deux colonnes : un panneau d’entrée pour téléverser une image, choisir le mode OCR et ajuster des paramètres avancés (taille d’image, mode de recadrage) ; et un panneau de sortie qui affiche le contenu extrait, les statistiques d’inférence et une image annotée avec boîtes autour des zones détectées.
• Contrôles dynamiques de l’UI : boutons radio, curseurs, cases à cocher et champs texte s’ajustent automatiquement selon les choix utilisateur et le mode sélectionné, pour une meilleure ergonomie et moins de configuration manuelle.
• Déclenchement de l’inférence et résultats : au clic sur le bouton Process Image, l’application appelle le gestionnaire OCR gr_ocr en lui passant les sélections en cours. Les sorties sont immédiatement rendues dans le panneau de résultats.

Remarque : vous devrez peut‑être redémarrer la session sur Google Colab si la sortie correspond encore à l’entrée précédente.

Notre application Gradio est prête : testons DeepSeek‑OCR avec une série d’exemples pratiques.

Exemple 1 : chart deep parsing

Dans la démo Gradio DeepSeek‑OCR, j’ai voulu évaluer l’extraction de données tabulaires à partir de graphiques, un défi encore difficile pour la plupart des modèles de vision/OCR.

J’ai essayé deux cas classiques :

• Un histogramme de style Statista ; et
• Un graphique d’analyse technique complexe truffé de signaux « BUY/SELL » et de superpositions numériques

DeepSeek‑OCR a renvoyé un tableau HTML pour chaque graphique, avec des cellules correspondant aux catégories, valeurs et libellés détectés dans l’image.

Points forts : le modèle a capturé tout le texte et la structure visibles du graphique, et la sortie en HTML est exploitable par machine et conserve la logique du tableau. Il a même traité des graphiques financiers complexes, cherchant à tabuler chaque nombre et libellé.

Limites : la sortie brute est très verbeuse, avec beaucoup de balises <td> et <tr>, difficile à lire d’un coup d’œil. Sur des graphiques complexes, le modèle duplique parfois des entrées ou perd la structure visuelle de haut niveau, générant un tableau foisonnant de signaux « BUY »/« SELL » répétés et de valeurs.

En production, on post‑traitera l’HTML pour la lisibilité ou on l’importera dans Excel ou Pandas.

Le parsing de graphiques de DeepSeek‑OCR ressemble à une fonctionnalité intelligente de numérisation de graphiques, mais la sortie riche en HTML convient mieux à des pipelines de données en aval qu’à une revue humaine rapide.

Exemple 2 : extraction de formules chimiques

Pour le test suivant, je voulais évaluer l’extraction d’informations chimiques depuis des images structurées. Le mode chimie de DeepSeek‑OCR vise à convertir à la fois des données chimiques tabulaires et des structures moléculaires graphiques en formats lisibles par machine, comme des tableaux HTML et la notation SMILES.

J’ai téléversé deux types d’images pour cet essai, et voici ce que j’ai observé :

• Extraction de formules textuelles : le modèle a correctement transcrit des noms et formules moléculaires (comme « Glucose : C₆H₁₂O₆ », « Butane : C₄H₁₀ »). Cependant, la sortie est du code de tableau HTML brut, structuré mais peu lisible d’un coup d’œil. La conversion image → tableau a été rapide et plutôt précise pour du texte simple.

• Reconnaissance de structures moléculaires : pour des diagrammes chimiques, DeepSeek‑OCR a tenté d’extraire les chaînes SMILES correspondantes. Par exemple, il a généré un SMILES pour l’éthane et le propane. S’il a bien reconnu la nature chimique des images, les SMILES générés ne sont pas toujours chimiquement valides, révélant des limites sur des structures plus complexes.

Dans l’ensemble, la capacité d’extraction chimique permet de numériser rapidement des données et de tenter la reconnaissance de structures, mais des raffinements sont nécessaires pour un parsing chimique fiable, surtout sur des structures complexes.

Exemple 3 : OCR d’écriture manuscrite

J’ai ensuite testé des notes manuscrites, un classique difficile pour l’OCR, surtout lorsque l’écriture est stylisée ou de tailles variables. 

J’ai téléversé une liste de chimie manuscrite, avec des noms de composés sur papier ligné. En mode Document to Markdown, le modèle a extrait le texte et préservé la structure de manière étonnamment fidèle. Il a reconnu l’en‑tête et listé chaque composé sur sa propre ligne, comme dans l’image. Les boîtes englobantes confirment la bonne segmentation des lignes et blocs.

Ce résultat montre la capacité du modèle à transcrire du manuscrit en texte numérique. Quelques détails de mise en forme peuvent se perdre, mais l’extraction globale a été très précise pour cet exemple.

Exemple 4 : extraction d’équations

Autre test standard : lire et interpréter correctement des équations mathématiques en notation « livre de cours ». J’ai téléversé une image avec des équations complexes en style LaTeX pour évaluer la détection et l’extraction/formatage des expressions.

DeepSeek‑OCR a détecté les quatre équations et les a extraites en chaînes LaTeX. La sortie est proprement structurée, chaque équation sur sa propre ligne au format LaTeX standard. 

Les boîtes englobantes se superposent correctement (à peu près) à l’image d’origine, montrant une bonne localisation/segmentation des expressions.

Point notable : la structure mathématique est conservée avec des commandes comme \frac pour les fractions et la bonne mise en forme des variables, ce qui rend le résultat réutilisable tel quel en documentation. 

Exemple 5 : extraction de tableaux

L’une des tâches OCR les plus utiles est l’extraction de données tabulaires depuis des images de documents (rapports scannés, articles, jeux de données). Pour évaluer DeepSeek‑OCR, j’ai téléversé un tableau comparatif économique structuré sur plusieurs pays.

Après avoir choisi le mode « Chart Deep Parsing », DeepSeek‑OCR a cherché à convertir le tableau visuel en structure HTML. Le contenu extrait (à droite) contient des balises <table> et <td> qui mappent lignes et colonnes en texte. Les boîtes englobantes confirment la bonne détection/segmentation de la zone principale du tableau.

L’extraction est fiable pour des tableaux simples, même si un post‑traitement reste souhaitable car l’HTML brut est peu convivial pour une relecture rapide ou une analyse en aval.

Exemple 6 : OCR sur des mèmes

J’ai voulu tester l’extraction de texte sur des mèmes populaires, un cas réel où le texte est superposé à des arrière‑plans complexes, avec des polices variées et hors des structures documentaires classiques.

J’ai téléversé un mème classique avec texte blanc, en capitales, sur une scène de film (Leonardo DiCaprio dans Django Unchained) et lancé le mode Document to Markdown.

Source : Media.io

Le résultat OCR a été étonnamment robuste. Tous les mots pertinents ont été capturés dans le bon ordre, sans fautes ni omissions, malgré l’arrière‑plan complexe. 

Sans balisage structurel, l’extraction reste très exploitable pour l’analyse de sentiments des mèmes, la modération de contenu ou la recherche textuelle.

Exemple 7 : OCR multilingue

Un des atouts de DeepSeek‑OCR est le support du multilingue, très utile pour des documents ou images mêlant plusieurs langues.

J’ai testé cette capacité avec divers échantillons, notamment un panneau de rue réel en chinois, et un exemple synthétique mélangeant chinois, japonais et coréen.

Source : DeepSeek OCR Hugging Face

Sur ces échantillons, le mode document‑vers‑Markdown a bien détecté et extrait les écritures non anglaises. Pour la photo de rue, le modèle a identifié et restitué tout le paragraphe en chinois. 

Sur l’exemple multilingue, il a correctement séparé et étiqueté les sections chinoise, japonaise et coréenne, en préservant leur formatage et leurs blocs de texte. Les boîtes englobantes montrent une détection précise des régions de texte de chaque langue.

Deux réserves toutefois :

• Vitesse de traitement : l’OCR multilingue est sensiblement plus lent que l’anglais seul ou l’extraction de tableaux. Mes tests montrent un temps plus long, sans doute dû à la détection et au décodage multi‑écritures.
• Erreurs occasionnelles : parfois, la sortie contient des tokens redondants ou un texte mal formaté.

Malgré ces points, DeepSeek‑OCR offre un OCR multilingue solide, capable de gérer des écritures mêlées et des photos du monde réel.

DeepSeek‑OCR : conclusions

DeepSeek‑OCR comble le fossé entre l’OCR classique et les LLM multimodaux modernes. Son grand atout est sa polyvalence : un pipeline unique qui lit des documents scannés, extrait des tableaux et graphiques complexes, comprend équations et structures chimiques, et gère même les mèmes, l’écriture manuscrite et des dizaines de langues.

Cela dit, DeepSeek‑OCR n’est pas parfait. Les sorties de graphiques et tableaux peuvent être trop verbeuses, la reconnaissance de structures chimiques est parfois insuffisante et le multilingue peut être nettement plus lent. Les mises en page visuelles complexes exigent souvent du post‑traitement.

Mais pour la recherche, l’académique, le prototypage rapide et toutes les situations nécessitant un OCR avancé au‑delà du texte brut, DeepSeek‑OCR s’impose déjà comme une nette avancée face aux outils historiques. 

Pour approfondir l’écosystème DeepSeek, nous vous recommandons le cours Working with DeepSeek in Python.