OCR inteligente con IA en Linux

Vistas: 548
0:00 / 0:00
OCR inteligente con IA en Linux

Te puedo asegurar que una de las cosas que más me saca de quicio es que alguien me pase una captura de pantalla en lugar del texto directamente. Todos lo hemos sufrido. Llega un mensaje al chat del trabajo, al grupo de Telegram o al correo, y en lugar de un texto que puedas copiar y pegar, te encuentras con una imagen. Y claro, tienes que ponerte a escribir manualmente todo lo que ves ahí, con el riesgo de equivocarte y el tiempo que se pierde.

Pero esto no es solo una cuestión de pereza ajena. También tiene que ver con nuestra propia productividad. A mí me pasó hace unas semanas, cuando empecé a hacer capturas de pantalla de los resultados de mis entrenamientos de running para pasárselas a mi agente Hermes. En lugar de dictarle todos los datos manualmente, que era un coñazo, hacía una captura rápida y se la pasaba. La cuestión es que él necesitaba el texto, no la imagen, así que me puse a buscar una solución que combinara lo mejor del OCR tradicional con la inteligencia artificial para conseguir buenos resultados.

Y de ahí nació todo esto que te voy a contar en el episodio de hoy. Una combinación de ImageMagick para preprocesar la imagen, Tesseract para el OCR y un modelo de lenguaje local, en este caso Llama 3.2, para corregir los errores y darle formato al resultado. He creado un script en Python que automatiza todo el proceso y que además es capaz de detectar el tipo de contenido al que se enfrenta. ¿Te parece interesante? Pues vamos allá.

El problema de las capturas de pantalla

¿Cuántas veces te ha pasado que recibes una imagen con información que necesitas digitalizar? Puede ser una captura de pantalla de una conversación, un PDF escaneado, un documento fotografiado con el móvil o incluso una tabla con datos de una web. En todas estas situaciones, el texto no es seleccionable, no se puede copiar y tienes que transcribirlo a mano.

Hasta ahora, mi postura era clara: si quieres que haga algo con tu información, dámela en texto. Pero la realidad es que la gente no va a cambiar sus hábitos, y cada vez es más común compartir información en formato imagen. Así que, en lugar de luchar contra ello, decidí buscar una solución tecnológica que me permitiera extraer ese texto de forma fiable.

La solución pasa por el OCR (Optical Character Recognition), una tecnología que lleva décadas entre nosotros pero que ha evolucionado muchísimo. En Linux tenemos herramientas potentes y, lo mejor de todo, gratuitas y de código abierto. El problema es que el OCR por sí solo no es perfecto, especialmente cuando las imágenes no están en condiciones óptimas. Y aquí es donde entra la inteligencia artificial para darle un empujón al resultado.

El pipeline completo: de la imagen al texto limpio

Antes de meterme en detalles técnicos, déjame explicarte el flujo completo que he diseñado. Es un proceso en cuatro fases:

  1. Captura o recepción de la imagen — haces una captura de pantalla o recibes un archivo de imagen
  2. Preprocesamiento con ImageMagick — preparas la imagen para que el OCR funcione mejor
  3. OCR con Tesseract — extraes el texto de la imagen
  4. Corrección con IA — pasas el texto por un modelo de lenguaje para limpiar errores y dar formato

Cada una de estas fases tiene su importancia, pero te diría que las dos que marcan la diferencia son el preprocesamiento y la corrección con IA. Sin ellas, el resultado es mediocre. Con ellas, el resultado es sorprendentemente bueno.

Captura de imagen en Linux

Lo primero es obtener la imagen. Si ya te la han pasado, no tienes que hacer nada. Pero si necesitas capturar tu propia pantalla, en Linux tienes varias opciones.

En mi caso, como estoy usando Wayland, he tenido que buscar alternativas a las herramientas clásicas de X11. Pero no te preocupes, porque tanto para Wayland como para X11 tienes opciones de sobra:

  • ImageMagick (import) — la herramienta clásica, funciona en X11
  • grim — el estándar en Wayland, ultrarrápido y sencillo
  • slurp — para seleccionar regiones en Wayland, complementa a grim
  • scrot — otra opción para X11, muy ligera
  • maim — más moderna, con opciones de retardo y selección

La cuestión es que da igual cuál uses. El pipeline que te voy a contar funciona con cualquier imagen que le pases, ya sea una captura de pantalla, una foto de un documento o un PDF escaneado.

Preprocesamiento con ImageMagick: el secreto del éxito

Y aquí llegamos al punto crítico. Si le pasas una imagen directamente a Tesseract, el resultado va a tener errores. Muchos errores. He llegado a medir tasas de error de hasta el 30% en capturas de pantalla sin procesar. ¿El motivo? Tesseract funciona mucho mejor con imágenes en blanco y negro de alto contraste, sin ruido y con el texto perfectamente alineado.

ImageMagick, en su versión 7 (que es la que uso ahora), se maneja con el comando magick. Ha sido un cambio importante respecto a la versión 6, donde se usaba convert. Si tienes Ubuntu 25.10 o una versión reciente, es muy probable que ya tengas ImageMagick 7 instalado. Si no, puedes instalarlo fácilmente con sudo apt install imagemagick o compilarlo desde fuente si necesitas las últimas funcionalidades.

Las operaciones de preprocesamiento que he encontrado más útiles son estas:

Colorspace Gray

Eliminar el color es el primer paso. El color es ruido para Tesseract. Con -colorspace gray conviertes la imagen a escala de grises, reduciendo la información a procesar y eliminando las distracciones cromáticas.

magick input.png -colorspace gray output.png

Normalize

Mejora el contraste de la imagen. Si tienes una captura con fondos degradados o iluminación desigual, -normalize ajusta los niveles de blanco y negro para que el texto destaque más.

magick input.png -colorspace gray -normalize output.png

Threshold

Convierte la imagen a blanco y negro puro. Es una operación brutal que elimina cualquier matiz de gris. El parámetro es el porcentaje de umbral. Un 50% suele funcionar bien para la mayoría de los casos, pero si el texto es muy claro o muy oscuro, puedes ajustarlo.

magick input.png -colorspace gray -normalize -threshold 50% output.png

Deskew

Endereza el texto. Si la imagen está ligeramente torcida, -deskew 40% la endereza automáticamente. Esto es especialmente útil para fotos de documentos hechas con el móvil.

magick input.png -deskew 40% -threshold 50% output.png

Sharpen

Afilia los bordes de las letras. Si el texto es borroso o tiene anti-aliasing (el suavizado de bordes típico de las capturas de pantalla modernas), -sharpen 0x1 ayuda a que los caracteres se distingan mejor.

magick input.png -sharpen 0x1 -threshold 50% output.png

La clave está en combinar estas operaciones en un pipeline que se ajuste al tipo de imagen que tengas. No es lo mismo una captura de pantalla de una terminal (texto blanco sobre fondo negro, nítido) que una foto de un documento impreso (fondo amarillento, texto borroso, posiblemente torcido).

Para capturas de pantalla de terminal, por ejemplo, mi pipeline es muy sencillo:

magick captura.png -colorspace gray -negate -threshold 40% output.png

El -negate invierte los colores, porque el texto blanco sobre fondo negro hay que pasarlo a texto negro sobre fondo blanco para que Tesseract lo procese bien.

Para fotos de documentos, el pipeline es más elaborado:

magick foto.jpg -colorspace gray -normalize -deskew 40% -sharpen 0x1 -threshold 55% output.png

La diferencia entre usar un pipeline adecuado y no hacerlo es abismal. Te lo digo por experiencia. He pasado de tasas de error del 30% a menos del 2% simplemente con un buen preprocesamiento.

Tesseract: el corazón del OCR

Tesseract es el motor de OCR de código abierto más conocido y utilizado. Originalmente fue desarrollado por Hewlett-Packard y luego pasó a ser mantenido por Google. La versión actual, Tesseract 5, incluye un motor de reconocimiento basado en redes neuronales LSTM que ofrece resultados muy superiores a las versiones anteriores.

La instalación es sencilla:

sudo apt install tesseract-ocr tesseract-ocr-spa

El paquete tesseract-ocr-spa incluye los datos de idioma para español. Si necesitas otros idiomas, puedes instalarlos con tesseract-ocr-{idioma}. Para catalán, por ejemplo, tesseract-ocr-cat.

El uso básico es tan simple como:

tesseract imagen.png stdout

Esto te devuelve el texto reconocido directamente en la terminal. Si quieres guardarlo en un archivo:

tesseract imagen.png salida

Y te creará salida.txt con el resultado.

Pero Tesseract tiene muchas opciones interesantes. Por ejemplo, puedes especificar el idioma con -l:

tesseract imagen.png stdout -l spa

O incluso combinar varios idiomas:

tesseract imagen.png stdout -l spa+eng

Y puedes limitar el conjunto de caracteres reconocidos con --psm (Page Segmentation Mode). Los modos más útiles son:

  • --psm 3 — detección automática de página (el que usa por defecto)
  • --psm 6 — asume un bloque uniforme de texto
  • --psm 7 — trata la imagen como una sola línea de texto
  • --psm 11 — texto sin formato, con orientación variable

Para capturas de pantalla, el modo 6 o 7 suele dar mejores resultados que el automático.

Diccionarios personalizados

Una de las funcionalidades que más me gusta de Tesseract es la posibilidad de usar listas de palabras personalizadas. Si los textos que vas a escanear son siempre de un dominio concreto (facturas, logs de sistema, código fuente), puedes crear un archivo de palabras y pasárselo a Tesseract para que mejore el reconocimiento.

El archivo debe tener una palabra por línea y se pasa con el parámetro --user-words:

tesseract imagen.png stdout -l spa --user-words mis-palabras.txt

Esto es especialmente útil para términos técnicos, nombres propios o palabras en otros idiomas que Tesseract no tenga en su diccionario por defecto.

El salto a Python: ocr_ai.py

Con todas estas piezas sobre la mesa, me puse a escribir un script que unificara todo el proceso. Al principio lo hice en Fish, porque me resulta cómodo para prototipar rápido, pero pronto me di cuenta de que necesitaba algo más estructurado. Así que lo pasé a Python, y el resultado es ocr_ai.py.

El script hace exactamente lo que te he contado, pero con una capa adicional de inteligencia: es capaz de detectar automáticamente el tipo de contenido que está procesando y ajustar el pipeline en consecuencia.

Detección automática del tipo de contenido

¿Cómo sabe el script si lo que tiene delante es código, una tabla o texto normal? Pues con heurísticas bastante sencillas pero efectivas:

  • Código: busca patrones como indentación, símbolos como {, }, =, ->, =>, palabras clave como def, class, if, for, fn, let, pub
  • Tablas: busca barras verticales |, números alineados, patrones de repetición, múltiples columnas
  • Prosa: si no detecta lo anterior, asume que es texto normal

En función de lo que detecte, aplica un pipeline de preprocesamiento diferente y, lo que es más importante, un prompt distinto para la corrección con IA.

Pipelines optimizados por tipo

Para código, el preprocesamiento es más agresivo con el threshold y la nitidez, porque necesitas que cada carácter, cada espacio y cada indentación se reconozcan correctamente. El prompt de IA se centra en restaurar la sintaxis, la indentación y no cambiar nombres de variables ni añadir líneas que no estaban.

Para tablas, el preprocesamiento intenta preservar las líneas divisorias y los espacios. El prompt de IA se enfoca en corregir números mal reconocidos, preservar la estructura de filas y columnas y no rellenar celdas vacías.

Para prosa, el preprocesamiento es más suave, y el prompt simplemente corrige acentos, puntuación y caracteres mal reconocidos sin alterar el significado.

El script y cómo usarlo

El script se llama desde la terminal con:

python3 ocr_ai.py imagen.png

Y te devuelve el texto procesado. También puedes combinarlo con un capturador de pantalla para hacerlo todo en un solo paso:

grim -g "$(slurp)" - | python3 ocr_ai.py - | wl-copy

Este comando hace lo siguiente: captura una región de la pantalla con grim y slurp, la pasa directamente a ocr_ai.py (el guión indica que lea de la entrada estándar), y el resultado se copia al portapapeles con wl-copy. En X11, usarías import y xclip respectivamente.

El resultado es que con un solo atajo de teclado, seleccionas una región de la pantalla y el texto procesado ya está en tu portapapeles, listo para pegar donde quieras.

Corrección con Llama 3.2: el toque de la IA

Y aquí llegamos al elemento diferencial. El OCR con Tesseract, incluso con un buen preprocesamiento, va a tener errores. Puede confundir una letra «l» con un número «1», una «O» con un «0», o fallar con acentos y caracteres especiales.

Para solucionarlo, he añadido una fase de corrección con un modelo de lenguaje local. En mi caso uso Llama 3.2, que es el modelo que Meta lanzó y que puedes ejecutar localmente con herramientas como Ollama.

¿Por qué un modelo local y no uno en la nube? Principalmente por dos razones: privacidad y velocidad. No quiero enviar capturas de pantalla de mis datos a ningún servidor externo, y además, un modelo local como Llama 3.2 en su versión pequeña (3B parámetros) responde en milisegundos cuando se ejecuta en una CPU moderna o en una GPU modestas.

La instalación de Ollama es trivial:

curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama3.2:3b

Y ya tienes el modelo listo para usar. Desde Python, puedes llamarlo a través de la API que expone Ollama en http://localhost:11434/api/generate.

Los prompts que uso son diferentes según el tipo de contenido detectado:

Para código:

Corrige errores de OCR en código fuente. Restaura la indentación. No inventes líneas. No cambies nombres de variables. Devuelve solo el código corregido.

Para tablas:

Corrige números mal reconocidos en esta tabla. Preserva la estructura de filas y columnas. No rellenes celdas vacías. Devuelve la tabla formateada.

Para prosa:

Corrige caracteres mal reconocidos, acentos y puntuación. No cambies el significado del texto. Devuelve solo el texto corregido.

La diferencia entre usar un prompt genérico y uno específico para cada tipo de contenido es muy notable. Con el prompt adecuado, el modelo entiende el contexto y aplica las correcciones correctas.

El código completo sería el siguiente,

ocr_ai.py
#!/usr/bin/env python3
"""
ocr-ai.py — OCR inteligente con detección automática de contenido
y post-procesado con IA (Ollama).

Captura una región de la pantalla o procesa una imagen existente,
detecta automáticamente el tipo de contenido (código, tabla, prosa),
ajusta los parámetros de Tesseract, y limpia errores con Ollama.

Uso:
  python3 ocr-ai.py                     # Captura + OCR + IA
  python3 ocr-ai.py -f captura.png      # Procesa imagen existente
  python3 ocr-ai.py -f captura.png --raw # Solo OCR, sin IA
  python3 ocr-ai.py -f captura.png --copy  # OCR + IA + al portapapeles

Dependencias:
  - Python 3.10+
  - ImageMagick (magick)
  - Tesseract (tesseract-ocr + tesseract-ocr-spa + tesseract-ocr-eng)
  - wl-clipboard (Wayland) o xclip (X11) para --copy
  - Ollama (ollama serve corriendo, modelo recomendado: llama3.2)
"""

import argparse
import json
import os
import re
import subprocess
import sys
import tempfile
from pathlib import Path

import requests


# ─── Configuración ─────────────────────────────────────────────────────────────

OLLAMA_HOST = "http://localhost:11434"
OLLAMA_MODEL = "llama3.2"
OLLAMA_TIMEOUT = 60

# Pipeline de ImageMagick por defecto
DEFAULT_PIPELINE = [
    "-colorspace", "Gray",
    "-normalize",
    "-threshold", "60%",
    "-deskew", "40%",
    "-sharpen", "0x1",
]

# Pipeline más agresivo para código (más contraste, menos ruido)
CODE_PIPELINE = [
    "-colorspace", "Gray",
    "-normalize",
    "-contrast-stretch", "2%",
    "-threshold", "55%",
    "-deskew", "40%",
    "-sharpen", "0x2",
    "-morphology", "Close", "Octagon",
]

# Pipeline para tablas (preserva líneas)
TABLE_PIPELINE = [
    "-colorspace", "Gray",
    "-normalize",
    "-threshold", "50%",
    "-deskew", "30%",
    "-sharpen", "0x1",
    "-morphology", "Erode", "Octagon",
]


# ─── Detección de tipo de contenido ───────────────────────────────────────────

def detectar_tipo(texto: str) -> str:
    """
    Analiza el texto extraído por OCR y detecta el tipo de contenido.
    Devuelve: 'codigo', 'tabla', 'prosa' o 'desconocido'.
    """
    if not texto or len(texto.strip()) < 10:
        return "desconocido"

    lineas = texto.strip().split("\n")
    num_lineas = len(lineas)
    palabras = texto.split()
    num_palabras = len(palabras)

    # Heurísticas para código
    patrones_codigo = [
        r'\b(import|from|def |class |fn |let |var |const|function|int |float|void|return|if |else |for |while|switch|case |package|#include|using namespace|public |private |static)\b',
        r'[{}()\[\];]',
        r'==|!=|<=|>=|->|=>|\+\+|--',
        r'^\s*[#//]\s',
        r'\.\w+\(',
        r'["\'].*["\']\s*[;,]',
    ]
    puntuacion_codigo = 0
    for patron in patrones_codigo:
        if re.search(patron, texto, re.IGNORECASE | re.MULTILINE):
            puntuacion_codigo += 2

    # Más peso si hay indentación consistente (código suele estar indentado)
    indentadas = sum(1 for l in lineas if l.startswith("    ") or l.startswith("\t"))
    if indentadas > num_lineas * 0.3:
        puntuacion_codigo += 3

    # Puntuación por densidad de palabras (código tiene menos variedad léxica)
    if num_palabras > 0 and len(set(palabras)) / num_palabras < 0.4:
        puntuacion_codigo += 2

    # Heurísticas para tabla (más restrictivas)
    patrones_tabla = [
        r'\|.*\|.*\|',
        r'\+[-+]+\+',
        r'(Nº|#|Item|Producto|Precio|Cantidad|Total|Unidades)\s*\||\|.*\|',
        r'^\s*\d+\..*\d+[.,]\d+',
    ]
    puntuacion_tabla = 0
    for patron in patrones_tabla:
        if re.search(patron, texto, re.IGNORECASE | re.MULTILINE):
            puntuacion_tabla += 2

    # Tablas suelen tener muchas líneas cortas con estructura repetitiva
    lineas_cortas = sum(1 for l in lineas if 5 < len(l.strip()) < 40)
    if num_lineas > 3 and lineas_cortas > num_lineas * 0.5:
        puntuacion_tabla += 2

    # Decisión
    if puntuacion_codigo >= puntuacion_tabla and puntuacion_codigo >= 4:
        return "codigo"
    elif puntuacion_tabla > puntuacion_codigo and puntuacion_tabla >= 3:
        return "tabla"
    elif num_palabras > 20 and puntuacion_codigo < 4 and puntuacion_tabla < 3:
        return "prosa"
    else:
        return "desconocido"


def psm_para_tipo(tipo: str) -> int:
    """Devuelve el PSM de Tesseract óptimo para cada tipo."""
    return {
        "codigo": 6,     # Bloque de texto uniforme
        "tabla": 6,      # Bloque uniforme (mejor para TSV)
        "prosa": 4,      # Texto a una columna
        "desconocido": 3, # Detección automática
    }.get(tipo, 3)


def pipeline_para_tipo(tipo: str) -> list:
    """Devuelve el pipeline de ImageMagick óptimo para cada tipo."""
    return {
        "codigo": CODE_PIPELINE,
        "tabla": TABLE_PIPELINE,
        "prosa": DEFAULT_PIPELINE,
        "desconocido": DEFAULT_PIPELINE,
    }.get(tipo, DEFAULT_PIPELINE)


# ─── Herramientas del sistema ─────────────────────────────────────────────────

def check_deps():
    """Verifica que las dependencias del sistema están instaladas."""
    faltan = []
    for cmd, nombre in [("convert", "ImageMagick"), ("tesseract", "Tesseract")]:
        if subprocess.run(["which", cmd], capture_output=True).returncode != 0:
            faltan.append(nombre)
    if faltan:
        print(f"❌ Faltan dependencias: {', '.join(faltan)}", file=sys.stderr)
        print(f"   Instala: sudo apt install imagemagick tesseract-ocr tesseract-ocr-spa tesseract-ocr-eng", file=sys.stderr)
        sys.exit(1)


def capturar_pantalla(output_path: str):
    """Captura una región de la pantalla con import (ImageMagick)."""
    print("🔍 Selecciona una región con el ratón...", file=sys.stderr)
    result = subprocess.run(
        ["import", output_path],
        capture_output=True, text=True,
    )
    if result.returncode != 0:
        print("❌ Captura cancelada o fallida", file=sys.stderr)
        sys.exit(1)
    if not Path(output_path).exists() or Path(output_path).stat().st_size == 0:
        print("❌ No se generó la captura", file=sys.stderr)
        sys.exit(1)
    print(f"   ✅ Captura guardada: {output_path}", file=sys.stderr)


def preprocesar(input_path: str, output_path: str, pipeline: list):
    """Aplica el pipeline de ImageMagick a la imagen."""
    cmd = ["convert", input_path] + pipeline + [output_path]
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"❌ Error en preprocesado: {result.stderr}", file=sys.stderr)
        sys.exit(1)


def ocr(image_path: str, idiomas: str, psm: int) -> str:
    """Ejecuta Tesseract OCR y devuelve el texto extraído."""
    cmd = [
        "tesseract", image_path, "stdout",
        "-l", idiomas,
        "--psm", str(psm),
        "--oem", "1",
    ]
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        print(f"❌ Error en OCR: {result.stderr}", file=sys.stderr)
        return ""
    return result.stdout.strip()


def copiar_portapapeles(texto: str):
    """Copia texto al portapapeles (Wayland o X11)."""
    if subprocess.run(["which", "wl-copy"], capture_output=True).returncode == 0:
        subprocess.run(["wl-copy"], input=texto, text=True)
    elif subprocess.run(["which", "xclip"], capture_output=True).returncode == 0:
        subprocess.run(["xclip", "-selection", "clipboard"], input=texto, text=True)
    else:
        print("⚠️  Ni wl-copy ni xclip disponibles. Texto solo por stdout.", file=sys.stderr)
        return
    print("   📋 Copiado al portapapeles", file=sys.stderr)


# ─── Post-procesado con Ollama ────────────────────────────────────────────────

def llamar_ollama(system_prompt: str, user_prompt: str, model: str = OLLAMA_MODEL) -> str | None:
    """Llama a Ollama y devuelve el texto generado."""
    payload = {
        "model": model,
        "messages": [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_prompt},
        ],
        "stream": False,
        "options": {"temperature": 0.1, "num_predict": 2048},
    }

    try:
        resp = requests.post(
            f"{OLLAMA_HOST}/api/chat",
            json=payload,
            timeout=OLLAMA_TIMEOUT,
        )
        resp.raise_for_status()
        return resp.json().get("message", {}).get("content", "").strip()
    except requests.exceptions.ConnectionError:
        print("   ⚠️  Ollama no está disponible. Omitiendo corrección con IA.", file=sys.stderr)
        return None
    except Exception as e:
        print(f"   ⚠️  Error en Ollama: {e}. Omitiendo corrección.", file=sys.stderr)
        return None


def corregir_con_ia(texto: str, tipo: str, model: str = OLLAMA_MODEL) -> str:
    """Corrige errores de OCR usando Ollama, adaptado al tipo de contenido."""
    prompts = {
        "codigo": {
            "system": (
                "Eres un corrector de OCR especializado en código fuente. "
                "Tu tarea es corregir errores de reconocimiento óptico en código.\n\n"
                "REGLAS:\n"
                "1. Corrige caracteres mal reconocidos (0 por O, l por 1, etc.)\n"
                "2. Restaura indentación y formato del código original\n"
                "3. NO cambies nombres de variables, funciones o lógica\n"
                "4. NO inventes líneas de código que no están\n"
                "5. Mantén comentarios exactamente como están\n"
                "6. Preserva la sintaxis del lenguaje\n"
                "7. Devuelve SOLO el código corregido, sin explicaciones"
            ),
            "user": f"Corrige los errores de OCR en este código:\n\n```\n{texto}\n```",
        },
        "tabla": {
            "system": (
                "Eres un corrector de OCR especializado en tablas y datos numéricos. "
                "Tu tarea es corregir errores de reconocimiento óptico en tablas.\n\n"
                "REGLAS:\n"
                "1. Corrige números mal reconocidos (1.000 por 1000, etc.)\n"
                "2. Corrige símbolos monetarios (€ por EUR o similar)\n"
                "3. Preserva la estructura de filas y columnas\n"
                "4. NO inventes datos que no están en el original\n"
                "5. NO rellenes celdas vacías con datos inventados\n"
                "6. Si no estás seguro de un valor, déjalo como está\n"
                "7. Devuelve SOLO la tabla corregida, sin explicaciones"
            ),
            "user": f"Corrige los errores de OCR en esta tabla:\n\n```\n{texto}\n```",
        },
        "prosa": {
            "system": (
                "Eres un corrector de OCR especializado en texto en español. "
                "Tu tarea es corregir errores de reconocimiento óptico.\n\n"
                "REGLAS:\n"
                "1. Corrige caracteres mal reconocidos\n"
                "2. Corrige espacios perdidos o añadidos entre palabras\n"
                "3. Corrige puntuación y acentos cuando sea evidente\n"
                "4. NO cambies el significado del texto\n"
                "5. NO añadas información que no está\n"
                "6. Preserva el estilo y tono original\n"
                "7. Si una palabra no la reconoces bien, déjala como está\n"
                "8. Devuelve SOLO el texto corregido, sin explicaciones"
            ),
            "user": f"Corrige los errores de OCR en este texto:\n\n```\n{texto}\n```",
        },
        "desconocido": {
            "system": (
                "Eres un corrector de OCR. Tu tarea es corregir errores "
                "de reconocimiento óptico en el texto que se te pasa.\n\n"
                "REGLAS:\n"
                "1. Corrige solo errores evidentes de OCR\n"
                "2. NO inventes contenido\n"
                "3. NO cambies el formato o estructura\n"
                "4. Devuelve SOLO el texto corregido, sin explicaciones"
            ),
            "user": f"Corrige los errores de OCR en este texto:\n\n```\n{texto}\n```",
        },
    }

    p = prompts.get(tipo, prompts["desconocido"])
    resultado = llamar_ollama(p["system"], p["user"], model)
    return resultado if resultado else texto


# ─── Main ─────────────────────────────────────────────────────────────────────

def main():

    parser = argparse.ArgumentParser(
        description="ocr-ai: OCR inteligente con detección de contenido y corrección con IA",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""\
Ejemplos:
  python3 ocr-ai.py                     # Captura + OCR + IA
  python3 ocr-ai.py -f captura.png      # Procesa imagen existente
  python3 ocr-ai.py -f captura.png --raw # Solo OCR, sin IA
  python3 ocr-ai.py -f captura.png --copy --lang eng  # Código al portapapeles
        """,
    )
    parser.add_argument("-f", "--file", help="Archivo de imagen a procesar (si no, captura interactiva)")
    parser.add_argument("--lang", default="spa+eng", help="Idiomas para Tesseract (default: spa+eng)")
    parser.add_argument("--psm", type=int, default=0, help="PSM de Tesseract (0 = auto-detect)")
    parser.add_argument("--raw", action="store_true", help="OCR sin corrección con IA")
    parser.add_argument("--copy", action="store_true", help="Copiar resultado al portapapeles")
    parser.add_argument("--model", default=OLLAMA_MODEL, help=f"Modelo Ollama (default: {OLLAMA_MODEL})")
    parser.add_argument("--detect-only", action="store_true", help="Solo detectar tipo de contenido y salir")
    parser.add_argument("--debug", action="store_true", help="Modo verbose con información de depuración")

    args = parser.parse_args()

    # Verificar dependencias del sistema
    check_deps()

    # Configurar modelo Ollama
    ollama_model = args.model

    with tempfile.TemporaryDirectory(prefix="ocr-ai-") as tmpdir:
        if args.file:
            img_path = args.file
            if not Path(img_path).exists():
                print(f"❌ Archivo no encontrado: {img_path}", file=sys.stderr)
                sys.exit(1)
            print(f"📄 Procesando: {img_path}", file=sys.stderr)
        else:
            img_path = os.path.join(tmpdir, "captura.png")
            capturar_pantalla(img_path)

        # ─── 2. Preprocesar con pipeline por defecto ─────────────────────────
        proc_path = os.path.join(tmpdir, "procesada.png")
        print(f"🖼️  Preprocesando con ImageMagick...", file=sys.stderr)

        # Primera OCR para detectar tipo (con pipeline por defecto)
        first_ocr_path = os.path.join(tmpdir, "first_ocr.png")
        preprocesar(img_path, first_ocr_path, DEFAULT_PIPELINE)
        texto_bruto = ocr(first_ocr_path, args.lang, args.psm if args.psm > 0 else 3)

        if not texto_bruto:
            print("⚠️  No se detectó texto en la imagen", file=sys.stderr)
            sys.exit(0)

        # ─── 3. Detectar tipo de contenido ──────────────────────────────────
        tipo = detectar_tipo(texto_bruto)
        print(f"   📋 Tipo detectado: {tipo.upper()}", file=sys.stderr)

        if args.detect_only:
            print(f"\nTexto OCR (primeros 500 chars):\n{texto_bruto[:500]}")
            return

        # ─── 4. Reprocesar con pipeline óptimo para el tipo ─────────────────
        if args.psm == 0:
            psm_optimo = psm_para_tipo(tipo)
        else:
            psm_optimo = args.psm

        pipeline_optimo = pipeline_para_tipo(tipo)
        if args.debug:
            print(f"   🔧 Pipeline: {' '.join(pipeline_optimo)}", file=sys.stderr)
            print(f"   🔧 PSM: {psm_optimo}", file=sys.stderr)

        # Solo reprocesar si no era el pipeline por defecto
        if pipeline_optimo != DEFAULT_PIPELINE:
            print(f"   🔄 Reprocesando con pipeline optimizado para {tipo}...", file=sys.stderr)
            preprocesar(img_path, proc_path, pipeline_optimo)
        else:
            proc_path = first_ocr_path

        texto_ocr = ocr(proc_path, args.lang, psm_optimo)

        if not texto_ocr:
            print("⚠️  No se detectó texto tras reprocesado", file=sys.stderr)
            texto_ocr = texto_bruto  # Fallback al primer intento

        # ─── 5. Post-procesar con IA (opcional) ─────────────────────────────
        if args.raw:
            resultado = texto_ocr
        else:
            print(f"   🧠 Corrigiendo con {ollama_model}...", file=sys.stderr)
            resultado = corregir_con_ia(texto_ocr, tipo, ollama_model)
            if not resultado:
                resultado = texto_ocr  # Fallback si Ollama falla

        # ─── 6. Mostrar resultado ───────────────────────────────────────────
        print()
        print("╔══════════════════════════════════════════════════════════════╗")
        print(f"║  📝 RESULTADO ({tipo.upper()}){' ' * (27 - len(tipo))}║")
        print("╚══════════════════════════════════════════════════════════════╝")
        print()
        print(resultado)
        print()

        # ─── 7. Copiar al portapapeles ──────────────────────────────────────
        if args.copy:
            copiar_portapapeles(resultado)

        # ─── 8. Estadísticas ────────────────────────────────────────────────
        if args.debug:
            print(f"📊 Estadísticas:", file=sys.stderr)
            print(f"   Tipo detectado: {tipo}", file=sys.stderr)
            print(f"   PSM usado: {psm_optimo}", file=sys.stderr)
            print(f"   Caracteres OCR: {len(texto_ocr)}", file=sys.stderr)
            print(f"   Caracteres tras IA: {len(resultado)}", file=sys.stderr)
            if not args.raw and texto_ocr != resultado:
                # Mostrar cambios principales
                print(f"   ✏️  Correcciones aplicadas por IA", file=sys.stderr)


if __name__ == "__main__":
    main()

OCRmyPDF: OCR para PDFs escaneados

Hasta ahora hemos hablado de imágenes sueltas, pero ¿qué pasa con los PDFs escaneados? Un PDF escaneado no es más que un conjunto de imágenes sin capa de texto. No puedes buscar palabras, no puedes seleccionar texto, no puedes copiar nada.

Para eso existe OCRmyPDF, una herramienta fantástica que utiliza Tesseract por debajo y añade una capa de texto invisible al PDF. El resultado es un PDF que sigue siendo idéntico visualmente al original, pero que ahora tiene texto seleccionable y buscable.

La instalación:

sudo apt install ocrmypdf

Y el uso:

ocrmypdf --language spa escaneado.pdf resultado.pdf

El resultado es un PDF con el mismo aspecto pero con una capa de texto que puedes buscar, seleccionar y copiar. Es una herramienta imprescindible si trabajas con documentos escaneados de forma habitual.

Automatización: monitorización de directorios

Una de las cosas que más me gusta hacer es automatizar procesos. Y este era un candidato perfecto. ¿Por qué no hacer que cualquier imagen que caiga en un directorio se procese automáticamente?

Con inotifywait (de la herramienta inotify-tools) puedes monitorizar un directorio y ejecutar un script cuando se cree un nuevo archivo:

inotifywait -m -e create --format '%f' /ruta/al/directorio | while read archivo; do
    python3 ocr_ai.py "/ruta/al/directorio/$archivo" > "/ruta/al/directorio/$archivo.txt"
done

De esta manera, cada vez que arrastres una imagen a ese directorio, el script la procesa automáticamente y crea un archivo de texto con el resultado. Puedes incluso combinar esto con una carpeta compartida de Nextcloud, Syncthing o cualquier servicio de sincronización, y tener OCR automático desde el móvil.

Consejos prácticos y troubleshooting

Después de muchas pruebas, te dejo algunos consejos que te ahorrarán tiempo:

  • Si el texto es borroso, ajusta el threshold. Prueba con valores entre 40% y 65%. Un valor más bajo hace que más píxeles se consideren negros
  • Si hay ruido de fondo (puntos, manchas), aplica un filtro de morfología con -morphology close antes del threshold
  • Si el texto es muy pequeño, redimensiona la imagen antes de procesarla con -resize 200%. Esto mejora mucho el reconocimiento
  • Si es una foto de un documento, añade -median 3 para reducir el ruido de la cámara antes de cualquier otra operación
  • Si los errores de OCR son persistentes, activa la corrección con IA. A veces merece la pena aunque el resultado del OCR sea aceptable
  • Si trabajas siempre con el mismo tipo de documentos, crea un diccionario personalizado y un pipeline fijo. La especialización siempre gana
  • Si el texto tiene fondo degradado, prueba a aplicar -normalize varias veces o combínalo con -equalize para distribuir mejor los niveles de gris
  • Si el OCR devuelve caracteres extraños, verifica que tienes instalado el paquete de idioma correcto con tesseract --list-langs

Más allá del OCR: una reflexión sobre automatización

Lo que más me gusta de todo esto no es solo el resultado final, sino el proceso de llegar a él. Porque al final, lo que hemos hecho es combinar herramientas clásicas (ImageMagick, Tesseract) con una tecnología moderna (modelos de lenguaje) para resolver un problema cotidiano de una manera elegante y eficiente.

Y esto es aplicable a muchísimas cosas. No se trata de usar IA por usar, sino de entender dónde puede aportar valor real y combinarla con las herramientas que ya funcionan bien. En este caso, el OCR tradicional hace el trabajo pesado de reconocer caracteres, y la IA se encarga de la parte semántica: entender el contexto, corregir errores ambiguos y dar formato al resultado.

El script ocr_ai.py lo subiré a un gist para que puedas trastear con él. Y si tienes ideas para mejorarlo, ya sabes dónde encontrarme. En el grupo de Telegram de atareao con Linux siempre estamos dándole vueltas a este tipo de cosas.

Espero que te haya gustado el episodio y que le saques tanto partido como yo. La vida son dos días y uno ya ha pasado, así que mejor automatizar lo que podamos y dedicar el tiempo a lo que realmente importa.

Y si te animas a probar el script, ya me contarás qué tal te va. Siempre se puede mejorar, y de hecho, cuanto más lo uses, más ideas te van a surgir para añadir nuevas funcionalidades. Yo ya estoy pensando en la siguiente iteración, pero eso será en otro episodio.


Más información

Ver el vídeo de este episodio
Transcripción

Hola soy lorenzo y esto es atareado con Linux episodio número 814 seguimos con todo esto,

De la inteligencia artificial pero en este caso la vamos a combinar con un proceso de captura,

Proceso y extracción de texto básicamente hacer un ocr pero combinándolo en este caso,

Con con los modelos de lenguaje para conseguir un resultado mucho mejor en este caso voy a combinar,

Imagen magic tesseract y python con un modelo de lenguaje en este caso un modelo de lenguaje muy,

Sencillito que es llama 3.2 y con esto vamos a conseguir un resultado mucho mejor del que,

Cabría esperar si simplemente utilizamos tesseract sin hacer un preprocesamiento de la imagen y sin,

Hacer un post procesamiento del resultado así que vamos directos al turrón en este episodio te voy a,

Hablar sobre capturas de imágenes procesos y este tipo de cosas y empezamos como de costumbre por el,

Problema pero antes de entrar en el problema un detallito y es todo esto viene motivado no,

Solamente por hermes y por los modelos de lenguaje y por todo esto sino porque como te he contado en,

Algún episodio anterior lo que estoy haciendo es que cuando termino de correr en lugar de coger y,

Dictarle los resultados de la carrera o del entrenamiento que haya hecho lo que hago o lo,

Que se me ocurrió hace unos días era directamente hacer una captura de pantalla de la zona donde,

Aparecen todos los resultados simplemente por pereza por no dictarle toda esa información entonces yo le,

Pasaba eso y él se supone que tenía que procesarlo esto lo podéis hacer de distintas maneras una de,

Las maneras es directamente pasarle un ocr y otra de las maneras es directamente pasarle la imagen a un,

Modelo de lenguaje vía open router o cualquier otro tipo de solución y que se encargue yo pues bueno,

Estuve haciendo pruebas estuve como te digo yo estuve las candeleando un poco con todo esto y dije,

Ostras vamos a combinar todo todas estas herramientas para ver exactamente hacia dónde llegamos y empecé,

Por empecé por lo más sencillo simplemente aplicar lo que es utilizar el tesseract para hacer el ocr pero,

Inmediatamente eso dije ostras y si podemos hacer un preprocesamiento de la imagen para sacar mejores,

Resultados y luego poco a poco pues haciendo distintas operaciones distintas opciones pues he,

Llegado a conseguir una captura de pantalla o mejor dicho un procesamiento de lo que hay en una captura de,

Pantalla bastante interesante y esto es precisamente todo lo que te quiero contar y es que el problema,

Viene con cuántas veces has tenido que reescribir un texto de una imagen,

A qué me refiero bueno seguro que te ha pasado en ocasiones anteriores o en multitud de ocasiones que,

Alguien te pasa en lugar de unos datos directamente una captura de pantalla,

Esto es algo que es muy habitual la gente por no escribir hace directamente lo más sencillo una captura de pantalla,

Y ya está y entonces te lo tienes que escribir tú hasta el momento yo lo que he hecho es si quieres que haga o que,

Reinterprete o que haga lo que sea con lo que tú me das dámelo en texto porque yo no lo voy a copiar lo copias tú,

Pero ahora ya tenemos una solución mejor que es directamente pues o pasárselo a nuestro modelo de lenguaje,

Para que él se encargue precisamente de hacer todo este tipo de operaciones o bien,

Pues,

Utilizar un modelo o un OCR y luego,

Hacer estas cosas,

Al final bueno pues tienes una captura de pantalla un PDF escaneado un documento fotografiado,

Y luego tienes que,

Básicamente copiar toda esa información a mano,

Porque no lo puedes seleccionar el texto,

Solución bueno la solución es un poco lo que te estaba diciendo,

Hacer una captura de pantalla,

O sea mejor dicho con la captura de pantalla que te han pasado,

Bueno mejor dicho tienes dos opciones,

La primera como te decía anteriormente devolvérselo y que te lo den como tú quieres,

O la segunda opción es,

Capturar,

Procesar,

Realizar un OCR,

Y luego pues por ejemplo,

Copiarlo directamente en el portapapeles,

Esto es algo relativamente sencillo,

Simplemente tienes que utilizar,

Un comandillo,

Y ya lo tienes,

O sea simplemente sería hacer un pipeline,

Similar al que hicimos en episodios anteriores,

Donde haces,

Coges la imagen,

La preprocesas con magic,

Con image magic,

La escaneas con Tesseract,

Y luego incluso haces algún paso más,

Como te decía anteriormente que es,

El tema del modelo del lenguaje,

Y con esto directamente,

La copias al portapapeles,

Es algo relativamente sencillo,

Distintas operaciones,

Capturar la imagen,

Preprocesamiento,

Automatización con FIS,

Y un OCR,

Corrección con la IA,

Y luego,

Ya veremos que tenemos,

Algunas opciones adicionales,

Como es la posibilidad de,

Ver dónde podemos arreglar las cosas,

El primer paso evidentemente,

Es la captura de la imagen,

Bueno,

En este caso yo lo que estoy haciendo,

Y para todas las pruebas,

Que te contaré en este episodio,

Simplemente lo que he hecho,

Es no calentarme la cabeza,

Directamente hago una captura,

De pantalla de algo,

Y con esa captura de pantalla,

Se lo paso,

Existen distintas herramientas,

Para hacer la captura,

De pantalla,

En este caso por ejemplo,

Con image magic,

Tienes import,

Pero también tienes otras herramientas,

Como pueden ser,

Scrooge, Mime,

O otras similares,

En mi caso,

Como estoy utilizando,

Wayland,

Pues he utilizado,

Los equivalentes a Wayland,

Pero al final,

Todo este tipo de procesamiento,

De capturas de pantalla,

Lo puedes hacer,

Con,

Con,

Con distintas soluciones,

Como te digo,

Ya sea que utilices,

Import,

Scrooge,

O cualquier otra solución,

Te permite hacer,

Una captura de pantalla,

De una manera muy sencilla,

Si ya te pasa,

La captura de pantalla,

Pues mira,

Eso que,

Que ya tienes,

Luego lo siguiente,

Es capturar,

O mejor dicho,

Preprocesar la imagen,

Y es que,

El error más normal,

Que te vas a encontrar,

Es directamente,

La captura de pantalla,

Que te han pasado,

Se la metes a Tesseract,

Y ya tienes el resultado,

O sea,

Y ya tienes,

Y ya puedes,

Ya puedes procesar,

Con el OCR,

El problema,

Que vas a encontrarte,

Es que el resultado,

Pues va a tener,

Más errores,

De los normales,

Tesseract,

Funciona mejor,

Con,

Blanco y negro,

De alto contraste,

Que,

Simplemente,

Con la imagen,

Que le hayas pasado,

Con lo cual,

Pues hay que hacer,

Una serie de,

Preprocesamientos,

Para que todo funcione,

Un poquito mejor,

En este caso,

Por ejemplo,

Utilizando,

Image Magic,

Puedes utilizar,

Color Scrape Gray,

Que lo que va a hacer,

Es eliminar,

El color,

Porque al final,

El color es ruido,

Puedes utilizar,

Normalize,

Para mejorar,

El contraste,

Threshold,

Que lo que hace es,

Utiliza,

Blanco, negro,

Puro,

En función,

Del porcentaje,

Más o menos,

Luego tienes,

Descue,

Que lo que hace,

Es enderezar,

El texto,

Que esté torcido,

Y Sharpen,

Que lo que hace,

Es digamos,

Afila,

O redibuja,

O le da,

Más contorno,

Al borde,

De letras,

Esto es,

Simplemente,

Utilizando,

Image Magic,

No tienes que utilizar,

Absolutamente,

Nada más,

Con solamente,

Image Magic,

Que lo tendrías,

Yo cuando empecé,

Con todo esto,

Estaba,

La versión 6,

He tenido que darle,

Una vuelta,

A utilizar,

La versión 7,

Porque por ejemplo,

Antes se utilizaba,

Convert,

Y ahora ya se utiliza,

Magic,

Como la herramienta,

Por defecto,

Para todo,

Para procesar,

La imagen,

Para capturar,

La pantalla,

Para identificar,

Todo esto,

Lo haces directamente,

Ya con Magic,

Y con esto,

Con estas,

Con distintas,

Opciones,

Como por ejemplo,

Magic,

Captura,

.Png,

Color,

Space,

Grey,

En fin,

Le pasas una imagen,

Y con distintas opciones,

Con distintas,

Pipelines,

Puedes conseguir,

Un resultado,

Mucho mejor,

Desde,

Capturas de pantalla,

Pura y dura,

O un pipeline,

Para fotos,

De documentos,

O un pipeline,

Para texto,

Muy pequeño,

O también,

Un pipeline,

Para capturas,

Con gradientes,

De estas capturas,

Donde tienes,

En un lado,

Por ejemplo,

Naranja,

Claro,

Y en el otro lado,

Naranja oscuro,

Bueno,

Con estas,

Distintas pipelines,

Puedes hacer,

Distintas operaciones,

Y conseguir resultados,

Mucho mejores,

Por ejemplo,

Con,

Cinco opciones,

Como puede ser,

El color space,

Normalizar,

El threshold,

Etcétera,

Lo que vas a conseguir,

Es,

Distintas,

O sea,

Vas a conseguir,

Un resultado,

Mucho mejor,

Que el que,

Obtendrías,

Si simplemente,

Le pasas,

La imagen,

A,

Tesseract,

Con la captura,

Directa,

Vas a tener,

Fondos con gradientes,

Texto con,

Anti-allation,

Es decir,

Que está suavizado,

Colores que confunden,

Al OCR,

Puede ser,

Que la imagen,

Esté,

O los textos,

Estén ligeramente,

Torcidos,

Con esto,

La tasa de error,

Puede llegar a ser,

El 30%,

Una vez le has pasado,

El pipeline,

Ya tienes,

Fondo blanco puro,

El texto es,

Negro nítido,

Vas a tener,

Blanco y negro,

Sin ruido,

En lugar de estar,

Ligeramente torcido,

Va a estar,

Perfectamente enderezado,

Y con toda,

Esta combinación,

El porcentaje,

De error,

De Tesseract,

Se reduce,

Apenas el 2%,

Bueno,

Más o menos,

Luego ya depende,

Todo un poco,

De las cosas,

Como vayan funcionando,

Para funcionar,

Con Tesseract,

Tienes que,

Instalar,

Evidentemente,

Tesseract,

Y con esto,

Puedes hacer,

Un OCR,

Básico,

Donde tú,

Simplemente le dices,

La imagen,

Que quieres,

Puedes seleccionar,

Idiomas,

Y puedes hacer,

Distintas operaciones,

Relativamente básicas,

Yo la verdad,

Es que,

Desde el principio,

Lo que he hecho,

Ha sido,

Preprocesar,

La imagen,

Nunca he utilizado,

La imagen,

Tal y como,

Venía de la captura,

De pantalla,

Y con esto,

Utilizando,

Bien Wayland,

Podrías copiar,

El resultado,

Directamente,

Con WLCopy,

A tu portapapeles,

Para poder utilizarlo,

O con Xpli,

También lo podrías,

Con estos dos,

Comandos,

Con Tesseract,

Y encadenado,

Con un pipe,

A WLCopy,

O a Xclip,

Lo que vas a,

Poder hacer,

Es que,

Sin ningún,

Archivo intermedio,

Capturas,

Procesas,

Y ya tienes,

El texto,

Listo,

Para pegar,

Directamente,

Desde el portapapeles,

Por ejemplo,

Puedes utilizar,

También,

Un OCR,

Con,

Un listado,

De palabras,

Clave,

Esto,

Normalmente,

O sea,

Si los textos,

Que normalmente,

Estás utilizando,

Son siempre,

Muy parecidos,

Vale la pena,

Que te crees,

Esos diccionarios,

Al final,

Al final,

De todo este tipo,

De operaciones,

Al final,

De todas estas cosas,

Yo lo que me he dado cuenta,

Es que,

En función,

De lo que vayas a hacer,

Tienes que utilizar,

Algunas herramientas,

U otras,

Esto es un poco,

Parecido,

A lo que te contaba,

Hace un par de episodios,

Al final,

Si vas a utilizar,

O si siempre vas a,

Escanear,

El mismo tipo,

De documentos,

Por ejemplo,

Si estás utilizando,

Un proceso,

Donde lo único,

Que haces,

Es escanear facturas,

Pues más o menos,

Los textos,

De las facturas,

Van a ser,

Parecidos,

Y lo único,

Que van a cambiar,

Van a ser,

Distintos conceptos,

Y distintos importes,

En estos casos,

Vale la pena,

Tener un diccionario,

Con toda la información,

Para,

Procesarla,

Igual que esto,

Si por ejemplo,

La imagen,

Que te viene,

Siempre es una imagen,

Que es,

Blanco y negro,

O que es,

Con un determinado,

Color,

Lo que tienes que hacer,

Es particularizar,

Tu pipeline,

Para que se adecue,

Perfectamente,

A lo que tú vas a hacer,

De esta manera,

Con estos pasos sencillos,

Lo que vas a partir,

O lo que vas a,

Mejor dicho,

Llegar a un resultado,

Mucho mejor,

Que si no lo particularizas,

Y esto,

De verdad,

Que se nota,

Muchísimo,

Cuando he empezado,

Con todo este episodio,

Directamente,

He hecho,

Distintas capturas,

De pantalla,

Y conforme iba,

Haciéndolas,

Me he ido apoyando,

En la IA,

Para ir preguntándole,

Cómo podía mejorar,

El resultado,

Directamente,

Le pasaba la imagen,

Tal y como,

Yo la capturaba,

Y le decía,

Lo que iba a utilizar,

Y,

Cómo iba a hacer,

La pipeline,

Es decir,

Que iba a pasar,

Primero una imagen,

Donde iba a realizar,

Determinados,

Preprocesamientos,

Los que él me dijera,

Luego,

Que iba a utilizar,

Tessera para hacer,

El OCR,

Y que él me dijera,

Exactamente,

Cómo lo podía ajustar,

Y luego,

Decirle que,

Voy a pasar,

Un modelo de lenguaje local,

Y con esto,

Con estos,

Distintos pasos,

Haciendo iteraciones,

Llegas a un resultado,

Muy interesante,

Al final,

Esto de las,

Por ejemplo,

Que te estaba diciendo,

De las,

Listas de palabras,

Personalizadas,

Eso está muy bien,

En función,

De lo que vayas a hacer,

Todo,

Todo funciona,

También puedes hacer,

OCR,

Masivos,

De,

PDFs,

Escaneados,

Para eso,

Tienes otras herramientas,

Como puede ser,

OCR,

Y PDF,

En el que puedes,

Añadir,

Por ejemplo,

La capa de texto,

A un PDF,

Que hayas escaneado,

Y así,

Sucesivamente,

Tienes distintas,

Herramientas,

OCR,

Y PDF,

Al final,

Lo que utiliza,

Es Tessera,

Por debajo,

Y le añade,

Una capa de texto,

Invisible,

Al PDF,

De manera que,

A partir de ahí,

Luego ya puedes buscar,

Es decir,

Partes de un PDF,

Donde solamente,

Tienes imágenes,

Y con OCR,

My PDF,

Lo que consigues,

Es además,

Añadirle un texto,

Al final,

Y después de todo esto,

Mi objetivo,

Como de costumbre,

Es automatizar,

Es decir,

Mi objetivo es,

Crear una herramienta,

Un script,

Una aplicación,

Un lo que sea,

Para que partiendo,

De una origen,

Podamos llegar,

A un objeto,

O podemos llegar,

A un resultado,

Óptimo,

Y para esto,

Pues los distintos,

Pasos que te digo,

Contando,

Siempre vienen,

Fantásticos,

Así lo que he hecho,

Ha sido un script,

En este caso,

Inicialmente,

Empecé con un script,

En fish,

Pero luego,

He ido modificando,

La Python,

He ido haciendo,

Distintas opciones,

Para exprimirlo,

Al máximo,

Por ejemplo,

Actualmente,

Yo lo que puedo hacer,

Es ahora mismo,

Es escadenear,

Lo que sea,

Por ejemplo,

Python ocr,

Ai.py,

Esto lo subiré,

A,

A un hist,

Para que se pueda utilizar,

Bueno,

Aquí ahora ya,

Directamente,

Puedo escanear,

Una imagen,

Por ejemplo,

Puedo escanear,

Esto de aquí,

Debajo,

Por ejemplo,

Donde yo tengo,

La información,

De la CPU,

Y lo que me va a hacer,

Es decirme,

Pues lo que ha capturado,

Resultado,

Desconocido,

¿Por qué resultado,

Desconocido,

Porque,

Yo lo que he hecho,

Ha sido,

En función,

Del tipo,

De lo que voy a trabajar,

Hacer algunas cosas,

U otras,

¿No,

Por ejemplo,

Si yo me fuera,

Algún código,

De cualquier,

Aplicación,

De alguno,

De los que he estado,

Haciendo,

Por ejemplo,

De Agents,

Si yo hago ahora,

Un ocr,

Él lo que va a hacer,

Es,

En principio,

Detectarme,

Exactamente,

El tipo,

De,

Lo que está haciendo,

Lo que,

Identificar exactamente,

El escaneo,

Por ejemplo,

Ahora,

Él ha sido capaz,

De identificar,

Que,

Lo que estábamos,

Escaneando,

Es código,

Entonces,

Él activa,

Determinados parámetros,

Para mejorarlo,

¿No,

Entonces,

Como se puede ver,

El resultado,

Es bastante,

Bastante,

Conseguido,

De hecho,

No ha fallado,

En absolutamente,

Nada,

Si es cierto,

Estoy haciendo,

Una captura,

De pantalla,

De un texto,

De una terminal,

Con lo cual,

El texto,

Es súper,

Como te digo,

Muy parecido,

Es texto,

De código,

Con lo cual,

Es muy sencillo,

De identificar,

Voy a ir,

Si me puedo,

Ir a mis notas,

Y allí,

Ver algún,

Algún episodio,

Que esté,

Más,

Digamos,

Que tenga,

El texto,

Por ejemplo,

Inclinado,

A ver si,

Encuentro alguno,

A ver si podemos,

Mejorar,

Bueno,

Le podemos poner,

Las cosas más difíciles,

A nuestro modelo,

Para,

Yo creo,

Que por aquí,

Mira,

Aquí hay uno,

Con scrapping,

Que viene en cursiva,

Pero además,

La cursiva,

Con la que lo estoy eligiendo,

Es una cursiva,

Que simula,

El trazo,

Humano,

A ver cómo lo detecta esto,

Vamos a hacer una prueba,

Además está bastante pequeño,

Ahora te digo,

Porque he hecho,

Hay más cosas,

Vale,

A ver cómo funciona,

Aquí,

Por ejemplo,

Ha detectado,

Que es,

Prosa,

Y ha sido capaz,

De identificar,

Que,

Scrapping,

Incluso,

En cursiva,

O la web,

Que es una B,

De tipo,

A mano alzada,

También lo ha detectado,

O sea que,

Realmente está funcionando bien,

También te tengo que decir,

Que todo esto viene,

De las distintas pruebas,

Que he ido haciendo,

Y en las distintas pruebas,

Por ejemplo,

Una de las cosas,

Que he hecho,

Ha sido,

Que cuando hace una captura,

De pantalla,

Bueno,

O cuando tiene una imagen,

Lo que haga,

Es por defecto,

Escanearla al doble,

Porque,

De esta manera,

Se consiguen,

Resultados mejores,

Bueno,

Y con esto,

No solamente,

Puedes hacer,

Una captura,

De pantalla,

Estática,

Sino que además,

Puedes estar vigilando,

Un determinado,

Directorio,

Ya sea con,

Innotify Wait,

O con cualquier otra,

Herramienta,

De manera que,

Cada vez que llegue,

Allí cualquier,

Archivo,

Cualquier imagen,

Lo que va a hacer,

Es directamente,

Escanearla,

Y lo va a escanear,

Y lo que puede hacer,

Es asociar,

El texto,

A una imagen,

Es decir,

Por ejemplo,

Si escanear la imagen,

.Png,

Imagen .png,

El que haga,

Todo el procesamiento,

Perdón,

Preprocesamiento,

Escaneo,

Y luego lo guarde,

Como imagen .txt,

Con el resultado,

Y esto,

Para determinadas operaciones,

Pues te va a venir,

Fantástico,

Al final,

Se trata,

Como de costumbre,

De automatizar,

Así por ejemplo,

También puedes,

Crear un menú interactivo,

Donde,

Puedas seleccionar,

Por ejemplo,

Una región,

De la pantalla,

O en fin,

Puedes hacer,

Todo tipo de operaciones,

Y con el,

Ocr.pi,

Que te he mostrado,

Pues haces un poco,

Lo mismo,

Que los scripts,

Que tenía yo inicialmente,

Detección automática,

Del tipo de contenido,

Un pipeline,

Optimizado,

Según,

El tipo de contenido,

Si es código,

Si es una tabla,

O si es una prosa,

Y luego,

Por último,

Lo que he añadido,

Y que te voy a contar,

A continuación,

Es una corrección,

Con oyama,

Para limpiar errores,

De ocr,

¿Por qué,

¿Por qué una corrección,

Con ia,

Bueno pues porque,

En muchas ocasiones,

Lo único que hacemos,

Es,

O sea lo que,

Lo que sucede,

Es que a lo mejor,

Parece una l,

O parece un 1,

Bueno pues con,

Un,

Un,

Post procesamiento,

Utilizando oyama,

Vamos a acertar,

Mucho,

Porque él va a saber,

Va a,

Identificar semánticamente,

Que ahí lo que va,

Es una l,

En el episodio 813,

Lo que estuve haciendo,

Era scrapear,

Webs con oyama,

Ahora vamos a utilizar,

El mismo modelo,

O se puede utilizar,

El mismo modelo,

Simplemente para limpiar,

El texto que sale,

Del ocr,

Así el pipeline,

Completo sería,

Haces una captura,

De pantalla,

La preprocesas,

Con magic,

Luego la,

Le pasas el ocr,

Con tesseract,

Y por último,

Eso te va a dar,

Un texto con errores,

Lo pasas ahora,

Con oyama,

Y por último,

Ya tienes el texto limpio,

Y formateado,

Con,

Una,

Pipeline,

Sin imagen,

Pues,

Lo que,

A partir de código,

Con contraste,

Y morfología,

Vas a obtener,

Una corrección,

De sintaxis,

Y restauración,

De indentación,

Gracias a la IA,

Con una tabla,

Al hacer,

Las operaciones,

Previas,

Lo que vas a,

Perder,

Es las líneas,

Y con,

El prom,

De IA,

Lo que hace,

Es corregir,

Los números,

Y los símbolos,

Y con,

Cuando te enfrentas,

A prosa estándar,

Lo único que hace,

Es corregir,

Acentos,

Y ortografía,

El script,

Es capaz de detectar,

De forma completamente,

Automática,

Con heurísticas,

Buscas,

Palabras clave,

Patrones de código,

Y estructuras de tabla,

Ajusta,

Image magic,

Tesseract,

Y el prom,

De IA,

Para obtener,

El resultado,

Más adecuado,

Como te digo,

En función,

De distintas,

Heurísticas,

De detección,

Determina,

Si es un código,

En base a patrones,

Símbolos,

Indentación,

Puntuación,

Si es una tabla,

Si es una tabla,

De tipo,

Con barras verticales,

Etcétera,

Números alineados,

Repetición,

Él ya sabe,

Que es una tabla,

Y si no sabe,

Lo que es,

Por defecto,

Va a decirte,

Que es prosa,

Entonces aquí,

No hay patrones,

De código,

Vas a ver,

Más de 20 palabras,

Y vas a identificar,

Que es una,

Pipeline estándar,

Y con todo esto,

Con esta,

Identificación,

Tan sencilla,

Es capaz de,

Llevar nuestra,

Imagen,

Hacia un pipeline,

O hacia otro,

Hacia el pipeline,

De código,

Hacia el pipeline,

De tablas,

Y a partir de ahí,

Ponerle el prompt,

Que tú quieras,

Por ejemplo,

Para código,

¿Qué prompt,

Le pondríamos,

Pues algo como,

Corrige errores,

De OCR,

En código fuente,

Restaura,

La indentación,

No inventes líneas,

No cambies,

Nombres de variables,

Para tablas,

Corrige números,

Mal reconocidos,

Preserva estructura,

De filas y columnas,

Y no rellenes,

Celdas vacías,

Y para prosa,

Por ejemplo,

Sería algo así,

Como corrige,

Caracteres mal reconocidos,

Corrige acentos,

Y puntuación,

Y no cambies,

El significado,

Son tres prompts,

Completamente distintos,

El mismo modelo,

Y el resultado,

Es mucho mejor,

En base,

A un prompt genérico,

Todo esto,

Es súper potente,

Ya ves que,

Al final,

Simplemente,

Lo que hemos hecho,

Ha sido,

Realizar,

Distintas,

Operaciones,

Y distintos tratamientos,

En función,

De a lo que nos,

Enfrentemos,

Sin saber,

Previamente,

A lo que nos,

Enfrentamos,

Perdón,

Ya te he dicho,

Que por ejemplo,

Una de las opciones,

Sería,

Monitorizar,

Un directorio,

Que tengas,

Y todas las imágenes,

Que caigan en ese,

Directorio,

Escanearlas,

Claro,

Tú a priori,

No vas a saber,

Si lo que está cayendo,

En ese directorio,

Es una,

Es una tabla,

O es una,

Factura,

O es simplemente,

El capítulo 1,

Del Quijote,

No tienes ni idea,

Con esta,

Identificación,

Heurística,

Es capaz,

O eres capaz,

De saber exactamente,

A lo que te vas a enfrentar,

Y en función de eso,

Hacer,

Un preprocesamiento,

Incluso,

Podrías hacer,

Una iteración,

Un primer,

Preprocesamiento,

O incluso,

Una primera,

Un primer análisis,

Para saber exactamente,

A dónde te ibas,

Para llegar,

A una,

Solución,

Final,

Donde,

Ajustas,

Mucho más,

El resultado,

Con una iteración,

O con dos iteraciones,

Según hacia dónde,

Vayas,

Llegados a este punto,

Bueno,

Qué es lo que podemos hacer,

Qué consejos tenemos,

Y qué travel setting,

Por ejemplo,

Si nos enfrentamos,

A texto borroso,

Podríamos ajustar,

El threshold,

A un 50,

Un 55,

Un 65%,

En función de,

Si el problema,

Es que el,

Formato es incorrecto,

Podemos utilizar,

Distintos códigos,

Si hay ruido,

Podemos utilizar,

Morfología,

Si el texto,

Es muy pequeño,

Directamente hacer,

Un redimensionamiento,

Antes de un threshold,

Si estamos haciendo,

Fotos de documentos,

Añadir la opción,

Median 3,

Si tienes errores,

De OCR persistentes,

Utilizar con corrección,

Por IA,

Incluso,

Podrías,

Como te decía,

Anteriormente,

Hacer iteraciones,

En el sentido,

De que,

Haces una primer pasada,

En esa primera pasada,

A lo mejor,

Piensas que es código,

Utilizando IA,

Utilizando un modelo,

De lenguaje,

Determinas con más,

Precisión,

Exactamente,

Qué tipo,

De modelo,

O qué tipo,

De documento,

Te enfrentas,

Y aplicar,

Lo que tengas,

Que aplicar,

Así que,

Estamos ante,

Una herramienta,

Súper potente,

Donde,

Única y exclusivamente,

Lo que tenemos,

Que hacer,

Nosotros,

Es,

Directamente,

Darle una vuelta,

A lo que,

Buscamos,

Al objetivo,

Y vuelvo,

Al principio,

Del principio,

De los principios,

En el sentido,

Que hace,

Algunos episodios,

Bastantes ya,

Estábamos hablando,

Por ejemplo,

De que,

Ahora ya puedes,

Crear tu aplicación,

Tu herramienta,

Lo que tú quieres hacer,

Puedes hacer,

Todo esto,

De una manera,

Sin tener,

Idea de programación,

O mejor dicho,

Sin siquiera,

Tener que entrar,

A las tripas,

De lo que estés haciendo,

Simplemente,

Partes de,

Una caja,

De entrada,

Donde tú,

Le dices,

El tipo de imágenes,

Que vas a hacer,

Y un resultado,

Que quieres obtener,

Y a partir de ahí,

Le das una serie,

De herramientas,

Como puede ser,

Un OCR,

Un Image Magic,

Distintas opciones,

Para que,

Él vaya procesando,

Y tú,

En dos,

Tres,

O cuatro,

Iteraciones,

Vas a obtener,

Un resultado,

Mucho mejor,

Del que habrías,

Obtenido nunca,

Y poco más,

Que decirte,

Esto es un poco,

Lo que quería contarte,

Una nueva vuelta,

De tuerca,

A los modelos,

De inteligencia,

O a la,

Inteligencia,

Artificial,

Pero saliéndonos,

Un poco,

De la zona,

De confort,

En el sentido,

De darle,

Más herramientas,

Para que pueda,

Hacer más cosas,

Y como te digo,

Esto es lo que quería,

Contarte en este nuevo episodio,

Espero que te haya gustado,

Y que lo hayas disfrutado,

Tanto como lo he disfrutado,

Yo sobre todo,

En todo esto,

Como te digo,

En un gist,

Que dejaré en las notas,

Del episodio,

Subiré el,

Ocrai.py,

Para que,

Puedas jugar,

Con él,

Lo que tú,

Consideres,

Y espero que te haya gustado,

El episodio,

Y que lo hayas disfrutado,

Y si puedes,

Ya sabes,

Una valoración,

En iVoox,

Apple Podcast,

Un mensaje,

Donde quieras,

Simplemente por el feedback,

Que ya sabes,

Que el feedback,

Es el alimento,

Del creador,

De contenido,

Y poco más que decirte,

Recordarte que este es un podcast,

De la red de podcast,

De sospechosos habituales,

Donde puedes encontrar,

Fantásticos y maravillosos podcasts,

Puedes participar,

En esta red,

Entrando en Telegram,

En WinTableTinfo,

Y de la misma manera,

Si quieres participar,

En el grupo,

Atareado con Linux,

Simplemente tienes que buscar,

Atareado con Linux,

En Telegram,

Y allí nos vas a encontrar,

Hablando de modelos de lenguaje,

De,

OCR,

Seguramente ahora,

Y de cualquier otra cosa,

Relacionado con Linux,

Y con el mundo,

Del open source,

Y poco más que decirte,

Recordad que la vida,

Son dos días,

Y uno ya ha pasado,

Así que disfruta,

Como si no hubiera mañana,

Y si puede ser,

Con Linux,

Y en este caso,

Con el OCR,

Un saludo,

Y nos escuchamos,

El próximo lunes,

Hasta luego.

Deja una respuesta