diff --git a/.claude/commands/documentation-review.md b/.claude/commands/documentation-review.md
new file mode 100644
index 0000000..0a3910a
--- /dev/null
+++ b/.claude/commands/documentation-review.md
@@ -0,0 +1,97 @@
+Review and validate the documentation for this Master's Thesis project.
+
+## Instructions
+
+1. **Read metrics source files first** to get the correct values:
+ - `docs/metrics/metrics_paddle.md` - PaddleOCR results
+ - `docs/metrics/metrics_doctr.md` - DocTR results
+ - `docs/metrics/metrics_easyocr.md` - EasyOCR results
+ - `docs/metrics/metrics.md` - Comparative summary
+ - `src/results/*.csv` - Raw data from 64 trials per service
+
+2. **Review UNIR guidelines** for formatting and structure rules:
+ - **`instructions/plantilla_individual.htm`** - **PRIMARY REFERENCE** for all styling (CSS classes, Word styles)
+ - **`instructions/plantilla_individual_files/`** - Support files with additional style definitions
+ - `instructions/instrucciones.pdf` - TFE writing instructions
+ - `instructions/plantilla_individual.pdf` - Official template preview
+
+ **IMPORTANT:** When styling elements (tables, figures, notes, quotes), ALWAYS check `plantilla_individual.htm` for existing Word/CSS classes (e.g., `MsoQuote`, `MsoCaption`, `Piedefoto-tabla`). Use these classes instead of custom inline styles.
+
+### UNIR Color Palette (from plantilla_individual.htm)
+
+| Color | Hex | Usage |
+|-------|-----|-------|
+| Primary Blue | `#0098CD` | Headings, titles, diagram borders |
+| Light Blue BG | `#E6F4F9` | Backgrounds, callout boxes, nodes |
+| Dark Gray | `#404040` | Primary text |
+| Accent Blue | `#5B9BD5` | Table headers, accent elements |
+| Light Accent | `#9CC2E5` | Table borders |
+| Very Light Blue | `#DEEAF6` | Secondary backgrounds, subgraphs |
+| White | `#FFFFFF` | Header text, contrast |
+
+### Table Styles (from template)
+- `MsoTableGrid` - Basic grid table
+- `MsoTable15Grid4Accent1` - Styled table with UNIR colors (header: `#5B9BD5`, borders: `#9CC2E5`)
+- `Piedefoto-tabla` - Table caption/source style
+
+3. **Validate each documentation file** checking:
+
+### Data Accuracy
+- All CER/WER values must match those in `docs/metrics/*.md`
+- Verify: baseline, optimized, best trial, percentage improvement
+- Verify: GPU vs CPU acceleration factor
+- Verify: dataset size (pages)
+
+### UNIR Formatting
+- Tables: `**Tabla N.** *Descriptive title in italics.*` followed by table, then `*Fuente: ...*`
+ - Table titles must describe the content (e.g., "Comparación de modelos OCR")
+- Figures: `**Figura N.** *Descriptive title in italics.*`
+ - Figure titles must describe the content (e.g., "Pipeline de un sistema OCR moderno")
+- Sequential numbering (no duplicates, no gaps)
+- APA citation format for references
+
+### Mermaid Diagrams
+- **All diagrams must be in Mermaid format** (no external images for flowcharts/charts)
+- All Mermaid diagrams must use the UNIR color theme
+- Required YAML frontmatter config (Mermaid v11+):
+ ```mermaid
+ ---
+ title: "Diagram Title"
+ config:
+ theme: base
+ themeVariables:
+ primaryColor: "#E6F4F9"
+ primaryTextColor: "#404040"
+ primaryBorderColor: "#0098CD"
+ lineColor: "#0098CD"
+ ---
+ flowchart LR
+ A[Node] --> B[Node]
+ ```
+- Colors: `#0098CD` (UNIR blue for borders/lines), `#E6F4F9` (light blue background)
+- All diagrams must have a descriptive `title:` in YAML frontmatter
+- Titles MUST be quoted: `title: "Descriptive Title"` (not `title: Descriptive Title`)
+- Titles should describe the diagram content, not generic "Diagrama N"
+- Verify theme is applied to all diagrams in `docs/*.md`
+
+**Note on Bar Charts (`xychart-beta`):**
+- Bar chart colors are **automatically converted to light blue** (`#0098CD`) during figure generation
+- The `xyChart.plotColorPalette` config in YAML frontmatter does NOT work reliably with mmdc
+- Instead, `generate_mermaid_figures.py` post-processes SVG to replace default colors (`#ECECFF`, `#FFF4DD`)
+- No manual color configuration needed in xychart-beta blocks - they will be styled automatically
+
+### Files to Review
+- `docs/00_resumen.md` - Resumen/Abstract
+- `docs/03_objetivos_metodologia.md` - Objectives
+- `docs/04_desarrollo_especifico.md` - Main results (most critical)
+- `docs/05_conclusiones_trabajo_futuro.md` - Conclusions
+- `docs/07_anexo_a.md` - Technical annex
+- `README.md` - Project overview
+
+4. **Report findings** with:
+ - List of incorrect values found (with file:line references)
+ - Formatting issues detected
+ - Specific corrections needed
+ - Overall documentation health assessment
+
+5. **Language**: All docs/* files must be in Spanish. README.md and CLAUDE.md can be in English.
diff --git a/.claude/commands/word-generation.md b/.claude/commands/word-generation.md
new file mode 100644
index 0000000..d913ef4
--- /dev/null
+++ b/.claude/commands/word-generation.md
@@ -0,0 +1,77 @@
+Generate the Word document for this Master's Thesis project.
+
+## Instructions
+
+Execute the TFM document generation pipeline in order:
+
+### Step 0: Clean Up Previous Output
+
+Remove the entire thesis_output folder to ensure a fresh build:
+```bash
+rm -rf thesis_output && mkdir -p thesis_output/figures
+```
+
+### Step 1: Generate Figures from Mermaid Diagrams
+
+Run the figure generation script using the virtual environment:
+```bash
+source .venv/bin/activate && python3 generate_mermaid_figures.py
+```
+
+**Input:** Mermaid code blocks from `docs/*.md`
+**Output:** `thesis_output/figures/figura_*.png` and `figures_manifest.json`
+
+**Notes:**
+- Bar charts (`xychart-beta`) are automatically post-processed to use light blue (`#0098CD`) bars
+- The script generates SVG first, replaces default colors, then converts to PNG via `cairosvg`
+- Other diagram types (flowchart, sequence, pie) use direct PNG generation via `mmdc`
+
+### Step 2: Apply Content to UNIR Template
+
+Run the content application script using the virtual environment:
+```bash
+source .venv/bin/activate && python3 apply_content.py
+```
+
+**Input:**
+- `instructions/plantilla_individual.htm` (UNIR template)
+- `instructions/plantilla_individual_files/` (template support files)
+- `docs/*.md` (chapter content)
+- `thesis_output/figures/*.png` (generated figures)
+
+**Output:** `thesis_output/` (htm + support files + figures)
+
+### Step 3: Report Results
+
+After successful execution, provide:
+1. Number of figures generated
+2. Number of tables formatted
+3. Path to output file
+4. Instructions for Word finalization:
+ - Open `thesis_output/plantilla_individual.htm` in Microsoft Word
+ - Press Ctrl+A then F9 to update all indices (contents, figures, tables)
+ - Adjust image sizes if needed (select image → right-click → Size and Position)
+ - Save as `.docx`
+
+### Prerequisites
+
+If scripts fail, check that dependencies are installed:
+```bash
+# Python dependencies (in .venv)
+source .venv/bin/activate && pip install beautifulsoup4 cairosvg
+
+# Mermaid CLI for figure generation
+npm install @mermaid-js/mermaid-cli
+```
+
+### Notes
+
+- **Bar chart colors**: The `generate_mermaid_figures.py` script automatically converts xychart-beta bar colors to UNIR light blue (`#0098CD`). This is done via SVG post-processing since Mermaid's xychart theming doesn't work reliably via config files.
+- **Color replacement**: Both `fill` and `stroke` attributes are replaced for colors `#ECECFF` and `#FFF4DD` (default Mermaid bar colors).
+- **Config file**: `mermaid.config.json` in root directory sets the base theme for all diagrams.
+
+### Error Handling
+
+- If `generate_mermaid_figures.py` fails: Check mmdc (mermaid-cli) is installed
+- If `apply_content.py` fails: Check beautifulsoup4 is installed
+- Report any errors with the specific step that failed
diff --git a/.gitea/workflows/ci.yaml b/.gitea/workflows/ci.yaml
index f6b2c8b..456d2f0 100644
--- a/.gitea/workflows/ci.yaml
+++ b/.gitea/workflows/ci.yaml
@@ -10,8 +10,9 @@ on:
branches:
- main
-env:
- PADDLE_VERSION: "3.0.0"
+concurrency:
+ group: ${{ github.workflow }}-${{ github.ref }}
+ cancel-in-progress: true
jobs:
essential:
@@ -34,7 +35,7 @@ jobs:
echo "Event: ${{ gitea.event_name }}" >> $GITHUB_STEP_SUMMARY
# PaddleOCR CPU image (amd64 only)
- build_cpu:
+ build_paddle_ocr:
runs-on: ubuntu-latest
needs: essential
steps:
@@ -63,7 +64,7 @@ jobs:
${{ needs.essential.outputs.image_cpu }}:latest
# PaddleOCR GPU image (amd64 only)
- build_gpu:
+ build_paddle_ocr_gpu:
runs-on: ubuntu-latest
needs: essential
steps:
diff --git a/.gitignore b/.gitignore
index c2762ec..62025a2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,8 @@ __pycache__/
dataset
results
.DS_Store
-.claude
+.claude/*
+!.claude/commands/
node_modules
src/paddle_ocr/wheels
src/*.log
diff --git a/README.md b/README.md
index 0d4c4f7..eeafb81 100644
--- a/README.md
+++ b/README.md
@@ -10,36 +10,39 @@
## Objetivo
-Optimizar el rendimiento de PaddleOCR para documentos académicos en español mediante ajuste de hiperparámetros, alcanzando un **CER inferior al 2%** sin requerir fine-tuning del modelo ni recursos GPU dedicados.
+Optimizar el rendimiento de PaddleOCR para documentos académicos en español mediante ajuste de hiperparámetros, alcanzando un **CER inferior al 2%** sin requerir fine-tuning del modelo.
-**Resultado alcanzado:** CER = **1.49%** (objetivo cumplido)
+**Resultado alcanzado:**
+- **Mejor trial (5 páginas):** CER = **0.79%** ✓ objetivo cumplido
+- **Dataset completo (45 páginas):** CER = **7.72%** (mejora del 12.8% respecto a baseline)
---
## Resultados Principales
-**Tabla.** *Comparación de métricas OCR entre configuración baseline y optimizada.*
+**Tabla.** *Comparación de métricas OCR entre configuración baseline y optimizada (GPU).*
| Modelo | CER | Precisión Caracteres | WER | Precisión Palabras |
|--------|-----|---------------------|-----|-------------------|
-| PaddleOCR (Baseline) | 7.78% | 92.22% | 14.94% | 85.06% |
-| **PaddleOCR-HyperAdjust** | **1.49%** | **98.51%** | **7.62%** | **92.38%** |
+| PaddleOCR (Baseline) | 8.85% | 91.15% | 13.05% | 86.95% |
+| **PaddleOCR-HyperAdjust (dataset)** | **7.72%** | **92.28%** | **11.40%** | **88.60%** |
+| **PaddleOCR-HyperAdjust (mejor trial)** | **0.79%** | **99.21%** | **7.78%** | **92.22%** |
-*Fuente: Elaboración propia.*
+*Fuente: [`src/results/raytune_paddle_results_20260119_122609.csv`](src/results/raytune_paddle_results_20260119_122609.csv)*
-**Mejora obtenida:** Reducción del CER en un **80.9%**
+**Mejora obtenida (dataset completo):** Reducción del CER en un **12.8%**
-### Configuración Óptima Encontrada
+### Configuración Óptima Encontrada (GPU)
```python
config_optimizada = {
- "textline_orientation": True, # CRÍTICO - reduce CER ~70%
- "use_doc_orientation_classify": False,
+ "textline_orientation": True, # CRÍTICO para layouts complejos
+ "use_doc_orientation_classify": True, # Mejora orientación de documento
"use_doc_unwarping": False,
- "text_det_thresh": 0.4690, # Correlación -0.52 con CER
- "text_det_box_thresh": 0.5412,
+ "text_det_thresh": 0.0462, # Correlación -0.52 con CER
+ "text_det_box_thresh": 0.4862,
"text_det_unclip_ratio": 0.0,
- "text_rec_score_thresh": 0.6350,
+ "text_rec_score_thresh": 0.5658,
}
```
@@ -68,7 +71,7 @@ PDF (académico UNIR)
| Algoritmo de búsqueda | OptunaSearch (TPE) |
| Métrica objetivo | CER (minimizar) |
| Trials concurrentes | 2 |
-| Tiempo total | ~6 horas (CPU) |
+| Tiempo total | ~1.5 horas (GPU RTX 3060) |
*Fuente: Elaboración propia.*
@@ -76,63 +79,95 @@ PDF (académico UNIR)
## Estructura del Repositorio
+```mermaid
+flowchart TB
+ subgraph root["MastersThesis/"]
+ direction TB
+
+ subgraph docs["docs/ - Capítulos TFM"]
+ d0["00-07 chapters (.md)"]
+ subgraph metrics["metrics/"]
+ m1["metrics_paddle.md"]
+ m2["metrics_doctr.md"]
+ m3["metrics_easyocr.md"]
+ end
+ end
+
+ subgraph src["src/ - Código fuente"]
+ subgraph paddle["paddle_ocr/"]
+ p1["paddle_ocr_tuning_rest.py"]
+ p2["Dockerfile.gpu/cpu"]
+ end
+ subgraph doctr["doctr_service/"]
+ dt1["doctr_tuning_rest.py"]
+ end
+ subgraph easy["easyocr_service/"]
+ e1["easyocr_tuning_rest.py"]
+ end
+ subgraph ray["raytune/"]
+ r1["raytune_ocr.py"]
+ r2["run_tuning.py"]
+ end
+ results["results/*.csv"]
+ dataset["dataset/"]
+ end
+
+ subgraph thesis["thesis_output/"]
+ htm["plantilla_individual.htm"]
+ figs["figures/figura_1-11.png"]
+ end
+
+ subgraph inst["instructions/"]
+ i1["instrucciones.pdf"]
+ i2["plantilla_individual.htm"]
+ end
+
+ scripts["apply_content.py
generate_mermaid_figures.py"]
+ config["claude.md
README.md"]
+ end
```
-MastersThesis/
-├── docs/ # Capítulos del TFM en Markdown (estructura UNIR)
-│ ├── 00_resumen.md # Resumen + Abstract + Keywords
-│ ├── 01_introduccion.md # Cap. 1: Introducción (1.1-1.3)
-│ ├── 02_contexto_estado_arte.md # Cap. 2: Contexto y estado del arte (2.1-2.3)
-│ ├── 03_objetivos_metodologia.md # Cap. 3: Objetivos y metodología (3.1-3.4)
-│ ├── 04_desarrollo_especifico.md # Cap. 4: Desarrollo específico (4.1-4.3)
-│ ├── 05_conclusiones_trabajo_futuro.md # Cap. 5: Conclusiones (5.1-5.2)
-│ ├── 06_referencias_bibliograficas.md # Referencias bibliográficas (APA)
-│ └── 07_anexo_a.md # Anexo A: Código fuente y datos
-├── thesis_output/ # Documento final generado
-│ ├── plantilla_individual.htm # TFM completo (abrir en Word)
-│ └── figures/ # Figuras generadas desde Mermaid
-│ ├── figura_1.png ... figura_7.png
-│ └── figures_manifest.json
-├── src/
-│ ├── paddle_ocr_fine_tune_unir_raytune.ipynb # Experimento principal
-│ ├── paddle_ocr_tuning.py # Script de evaluación CLI
-│ ├── dataset_manager.py # Clase ImageTextDataset
-│ ├── prepare_dataset.ipynb # Preparación del dataset
-│ └── raytune_paddle_subproc_results_*.csv # Resultados de 64 trials
-├── results/ # Resultados de benchmarks
-├── instructions/ # Plantilla e instrucciones UNIR
-│ ├── instrucciones.pdf
-│ ├── plantilla_individual.pdf
-│ └── plantilla_individual.htm
-├── apply_content.py # Genera documento TFM desde docs/ + plantilla
-├── generate_mermaid_figures.py # Convierte diagramas Mermaid a PNG
-├── ocr_benchmark_notebook.ipynb # Benchmark comparativo inicial
-└── README.md
-```
+
+**Descripción de directorios principales:**
+
+| Directorio | Contenido |
+|------------|-----------|
+| `docs/` | Capítulos del TFM en Markdown (estructura UNIR) |
+| `docs/metrics/` | Métricas de rendimiento por servicio OCR |
+| `src/paddle_ocr/` | Servicio PaddleOCR dockerizado |
+| `src/doctr_service/` | Servicio DocTR dockerizado |
+| `src/easyocr_service/` | Servicio EasyOCR dockerizado |
+| `src/raytune/` | Scripts de optimización Ray Tune |
+| `src/results/` | CSVs con resultados de 64 trials por servicio |
+| `thesis_output/` | Documento TFM generado + figuras PNG |
+| `instructions/` | Plantilla e instrucciones UNIR oficiales |
---
## Hallazgos Clave
-1. **`textline_orientation=True` es crítico**: Reduce el CER en un 69.7%. Para documentos con layouts mixtos (tablas, encabezados), la clasificación de orientación de línea es esencial.
+1. **`textline_orientation=True` es crítico**: Para documentos con layouts mixtos (tablas, encabezados), la clasificación de orientación de línea es esencial.
-2. **Umbral `text_det_thresh` importante**: Correlación -0.52 con CER. Valores óptimos entre 0.4-0.5. Valores < 0.1 causan fallos catastróficos (CER >40%).
+2. **`use_doc_orientation_classify=True` mejora resultados**: En la configuración GPU, la clasificación de orientación del documento demostró impacto positivo.
-3. **Componentes innecesarios para PDFs digitales**: `use_doc_orientation_classify` y `use_doc_unwarping` no mejoran el rendimiento en documentos académicos digitales.
+3. **Umbral `text_det_thresh` importante**: Correlación -0.52 con CER. En GPU, el valor óptimo fue 0.0462. Valores < 0.01 causan fallos catastróficos (CER >40%).
+
+4. **`use_doc_unwarping` innecesario para PDFs digitales**: La corrección de deformación no mejora el rendimiento en documentos académicos digitales.
---
## Rendimiento GPU
-Se realizó una validación adicional con aceleración GPU para evaluar la viabilidad práctica del enfoque en escenarios de producción.
+Los experimentos principales se ejecutaron con aceleración GPU para maximizar la eficiencia de la exploración de hiperparámetros.
**Tabla.** *Comparación de rendimiento CPU vs GPU.*
| Métrica | CPU | GPU (RTX 3060) | Aceleración |
|---------|-----|----------------|-------------|
-| Tiempo/Página | 69.4s | 0.55s | **126x** |
-| Dataset completo (45 páginas) | ~52 min | ~25 seg | **126x** |
+| Tiempo/Página | 69.4s | 0.84s | **82x** |
+| Dataset completo (45 páginas) | ~52 min | ~38 seg | **82x** |
+| 64 trials completos | ~6.4 horas | ~1.5 horas | **4.3x** |
-*Fuente: Elaboración propia.*
+*Fuente: [`src/raytune_paddle_subproc_results_20251207_192320.csv`](src/raytune_paddle_subproc_results_20251207_192320.csv) (CPU) y [`src/results/raytune_paddle_results_20260119_122609.csv`](src/results/raytune_paddle_results_20260119_122609.csv) (GPU).*
### Recomendación de Modelos
@@ -145,7 +180,7 @@ Se realizó una validación adicional con aceleración GPU para evaluar la viabi
*Fuente: Elaboración propia.*
-**Conclusión:** Para hardware con VRAM limitada (≤6 GB), los modelos Mobile ofrecen el mejor balance entre precisión y recursos. La aceleración GPU hace viable el procesamiento en tiempo real.
+**Conclusión:** Para hardware con VRAM limitada (≤6 GB), los modelos Mobile ofrecen el mejor balance entre precisión y recursos. La aceleración GPU (82×) hace viable la exploración exhaustiva de hiperparámetros y el procesamiento en tiempo real.
---
@@ -196,101 +231,8 @@ python src/paddle_ocr_tuning.py \
## Fuentes de Datos
- **Dataset**: 2 documentos UNIR (45 páginas total): Instrucciones TFE (24 pág.) + Plantilla TFE (21 pág.)
-- **Resultados Ray Tune (PRINCIPAL)**: `src/raytune_paddle_subproc_results_20251207_192320.csv` - 64 trials de optimización con todas las métricas y configuraciones
-
----
-
-## Generación del Documento TFM
-
-### Prerrequisitos
-
-```bash
-# Instalar dependencias de Python
-pip install beautifulsoup4
-
-# Instalar mermaid-cli para generación de figuras
-npm install @mermaid-js/mermaid-cli
-```
-
-### Flujo de Generación del Documento
-
-El documento TFM se genera en **3 pasos** que deben ejecutarse en orden:
-
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│ PASO 1: generate_mermaid_figures.py │
-│ ────────────────────────────────────────────────────────────────── │
-│ • Lee diagramas Mermaid de docs/*.md │
-│ • Genera thesis_output/figures/figura_*.png │
-│ • Crea figures_manifest.json con títulos │
-└─────────────────────────────────────────────────────────────────────┘
- ↓
-┌─────────────────────────────────────────────────────────────────────┐
-│ PASO 2: apply_content.py │
-│ ────────────────────────────────────────────────────────────────── │
-│ • Lee plantilla desde instructions/plantilla_individual.htm │
-│ • Inserta contenido de docs/*.md en cada capítulo │
-│ • Genera tablas con formato APA y figuras con referencias │
-│ • Guarda en thesis_output/plantilla_individual.htm │
-└─────────────────────────────────────────────────────────────────────┘
- ↓
-┌─────────────────────────────────────────────────────────────────────┐
-│ PASO 3: Abrir en Microsoft Word │
-│ ────────────────────────────────────────────────────────────────── │
-│ • Abrir thesis_output/plantilla_individual.htm │
-│ • Ctrl+A → F9 para actualizar índices (contenidos/figuras/tablas) │
-│ • Guardar como TFM_Sergio_Jimenez.docx │
-└─────────────────────────────────────────────────────────────────────┘
-```
-
-### Comandos de Generación
-
-```bash
-# Desde el directorio raíz del proyecto:
-
-# PASO 1: Generar figuras PNG desde diagramas Mermaid
-python3 generate_mermaid_figures.py
-# Output: thesis_output/figures/figura_1.png ... figura_8.png
-
-# PASO 2: Aplicar contenido de docs/ a la plantilla UNIR
-python3 apply_content.py
-# Output: thesis_output/plantilla_individual.htm
-
-# PASO 3: Abrir en Word y finalizar documento
-# - Abrir thesis_output/plantilla_individual.htm en Microsoft Word
-# - Ctrl+A → F9 para actualizar todos los índices
-# - IMPORTANTE: Ajustar manualmente el tamaño de las imágenes para legibilidad
-# (seleccionar imagen → clic derecho → Tamaño y posición → ajustar al ancho de página)
-# - Guardar como .docx
-```
-
-### Notas Importantes para Edición en Word
-
-1. **Ajuste de imágenes**: Las figuras Mermaid pueden requerir ajuste manual de tamaño para ser legibles. Seleccionar cada imagen y ajustar al ancho de texto (~16cm).
-
-2. **Actualización de índices**: Después de cualquier cambio, usar Ctrl+A → F9 para regenerar índices.
-
-3. **Formato de código**: Los bloques de código usan Consolas 9pt. Verificar que no se corten líneas largas.
-
-### Archivos de Entrada y Salida
-
-**Tabla.** *Relación de scripts de generación con sus archivos de entrada y salida.*
-
-| Script | Entrada | Salida |
-|--------|---------|--------|
-| `generate_mermaid_figures.py` | `docs/*.md` (bloques ```mermaid```) | `thesis_output/figures/figura_*.png`, `figures_manifest.json` |
-| `apply_content.py` | `instructions/plantilla_individual.htm`, `docs/*.md`, `thesis_output/figures/*.png` | `thesis_output/plantilla_individual.htm` |
-
-*Fuente: Elaboración propia.*
-
-### Contenido Generado Automáticamente
-
-- **53 tablas** con formato APA (Tabla X. *Título* + Fuente: ...)
-- **8 figuras** desde Mermaid (Figura X. *Título* + Fuente: Elaboración propia)
-- **25 referencias** en formato APA con sangría francesa
-- **Resumen/Abstract** con palabras clave
-- **Índices** actualizables (contenidos, figuras, tablas)
-- Eliminación automática de textos de instrucción de la plantilla
+- **Resultados GPU (PRINCIPAL)**: [`src/results/raytune_paddle_results_20260119_122609.csv`](src/results/raytune_paddle_results_20260119_122609.csv) - 64 trials de optimización con GPU
+- **Resultados CPU (referencia de tiempo)**: [`src/raytune_paddle_subproc_results_20251207_192320.csv`](src/raytune_paddle_subproc_results_20251207_192320.csv) - Para comparación de rendimiento CPU vs GPU
---
@@ -301,10 +243,10 @@ python3 apply_content.py
Este trabajo adoptó la estrategia de **optimización de hiperparámetros** en lugar de **fine-tuning** debido a que el fine-tuning de modelos OCR requiere datasets etiquetados extensos y tiempos de entrenamiento prohibitivos.
**Hardware utilizado:**
-- **Optimización (CPU)**: Los 64 trials de Ray Tune se ejecutaron en CPU (~69s/página)
-- **Validación (GPU)**: Se validó con RTX 3060 logrando 126x de aceleración (0.55s/página)
+- **Optimización (GPU)**: Los 64 trials de Ray Tune se ejecutaron con GPU RTX 3060 (~0.84s/página, ~1.5 horas total)
+- **Referencia CPU**: Se midió el tiempo en CPU para comparación (~69s/página)
-La optimización de hiperparámetros demostró ser una **alternativa efectiva** al fine-tuning, logrando una reducción del 80.9% en el CER sin reentrenar el modelo.
+La optimización de hiperparámetros demostró ser una **alternativa viable** al fine-tuning. El mejor trial alcanzó un CER de 0.79%, mientras que la validación sobre el dataset completo logró una mejora del 12.8%.
### Tareas Pendientes
@@ -321,9 +263,10 @@ La optimización de hiperparámetros demostró ser una **alternativa efectiva**
#### Completadas
- [x] **Estructura docs/ según plantilla UNIR**
-- [x] **Diagramas Mermaid**: 8 figuras generadas
+- [x] **Diagramas Mermaid**: 8+ figuras generadas
- [x] **Documento TFM unificado**: Script `apply_content.py`
-- [x] **Evaluación con GPU**: RTX 3060 - 126x más rápido (0.55s/página)
+- [x] **Optimización con GPU**: RTX 3060 - 82× más rápido (0.84s/página)
+- [x] **Infraestructura Docker**: 5 imágenes (PaddleOCR, EasyOCR, DocTR, RayTune)
### Dataset
@@ -372,6 +315,9 @@ Este proyecto es parte de un Trabajo Fin de Máster académico.
## Referencias
- [PaddleOCR](https://github.com/PaddlePaddle/PaddleOCR)
+- [EasyOCR](https://github.com/JaidedAI/EasyOCR)
+- [DocTR](https://github.com/mindee/doctr)
- [Ray Tune](https://docs.ray.io/en/latest/tune/index.html)
- [Optuna](https://optuna.org/)
- [jiwer](https://github.com/jitsi/jiwer)
+- [PyMuPDF](https://pymupdf.readthedocs.io/)
diff --git a/TFM_Sergio_Jimenez_OCR.docx b/TFM_Sergio_Jimenez_OCR.docx
index 73ea343..26e0681 100644
Binary files a/TFM_Sergio_Jimenez_OCR.docx and b/TFM_Sergio_Jimenez_OCR.docx differ
diff --git a/TFM_Sergio_Jimenez_OCR.pdf b/TFM_Sergio_Jimenez_OCR.pdf
index 31cb2dc..5ff9fa6 100644
Binary files a/TFM_Sergio_Jimenez_OCR.pdf and b/TFM_Sergio_Jimenez_OCR.pdf differ
diff --git a/apply_content.py b/apply_content.py
index 24c79d3..3699c22 100644
--- a/apply_content.py
+++ b/apply_content.py
@@ -3,8 +3,10 @@
import re
import os
+import shutil
from bs4 import BeautifulSoup, NavigableString
from latex2mathml.converter import convert as latex_to_mathml
+from PIL import Image
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
TEMPLATE_INPUT = os.path.join(BASE_DIR, 'instructions/plantilla_individual.htm')
@@ -120,13 +122,13 @@ def parse_md_to_html_blocks(md_content):
mermaid_lines.append(lines[i])
i += 1
- # Try to extract title from mermaid content (YAML format: title: "...")
+ # Try to extract title from mermaid content (YAML format)
mermaid_content = '\n'.join(mermaid_lines)
- # Match YAML format: title: "Title" or title: 'Title'
+ # Match title with quotes: title: "Something" or title: 'Something'
title_match = re.search(r'title:\s*["\']([^"\']+)["\']', mermaid_content)
if not title_match:
- # Fallback to non-YAML format: title "Title"
- title_match = re.search(r'title\s+["\']?([^"\'"\n]+)["\']?', mermaid_content)
+ # Match title without quotes: title: Something
+ title_match = re.search(r'title:\s*([^"\'\n]+)', mermaid_content)
if title_match:
fig_title = title_match.group(1).strip()
else:
@@ -143,8 +145,24 @@ def parse_md_to_html_blocks(md_content):
html_blocks.append(f'''
Figura {figure_counter}. {fig_title}
''') if os.path.exists(fig_path): - # Use Word-compatible width in cm (A4 text area is ~16cm wide, use ~12cm max) - html_blocks.append(f'''[Insertar diagrama Mermaid aquí]
''') @@ -165,7 +183,9 @@ def parse_md_to_html_blocks(md_content): code = '\n'.join(code_lines) # Escape HTML entities in code code = code.replace('&', '&').replace('<', '<').replace('>', '>') - html_blocks.append(f'{code}
{code}
+Tabla {table_counter}. {clean_title}
''') # Build table HTML with APA style (horizontal lines only, no vertical) - table_html = '{md_to_html_para(cell)} | '
table_html += '
{md_to_html_para(quote_text)}
') + html_blocks.append(f'{md_to_html_para(quote_text)}
') continue # Bullet list @@ -640,6 +661,15 @@ def main(): output_html = str(soup) write_file(TEMPLATE_OUTPUT, output_html) + # Copy template support files (header.htm, images, etc.) + support_files_src = os.path.join(BASE_DIR, 'instructions/plantilla_individual_files') + support_files_dst = os.path.join(BASE_DIR, 'thesis_output/plantilla_individual_files') + if os.path.exists(support_files_src): + if os.path.exists(support_files_dst): + shutil.rmtree(support_files_dst) + shutil.copytree(support_files_src, support_files_dst) + print(f"✓ Copied template support files") + print(f"✓ Done! Modified: {TEMPLATE_OUTPUT}") print("\nTo convert to DOCX:") print("1. Open the .htm file in Microsoft Word") diff --git a/claude.md b/claude.md index 4ab0fab..316339b 100644 --- a/claude.md +++ b/claude.md @@ -12,39 +12,41 @@ This is a **Master's Thesis (TFM)** for UNIR's Master in Artificial Intelligence ### Why Hyperparameter Optimization Instead of Fine-tuning -Due to **hardware limitations** (no dedicated GPU, CPU-only execution), the project pivoted from fine-tuning to hyperparameter optimization: -- Fine-tuning deep learning models without GPU is prohibitively slow -- Inference time is ~69 seconds/page on CPU -- Hyperparameter optimization proved to be an effective alternative, achieving 80.9% CER reduction +The project chose **hyperparameter optimization** over fine-tuning because: +- Fine-tuning requires extensive labeled datasets specific to the domain +- Hyperparameter tuning can improve pretrained models without retraining +- GPU acceleration (RTX 3060) enables efficient exploration of hyperparameter space -### Main Results +### Main Results (GPU - Jan 2026) | Model | CER | Character Accuracy | |-------|-----|-------------------| -| PaddleOCR Baseline | 7.78% | 92.22% | -| PaddleOCR-HyperAdjust | **1.49%** | **98.51%** | +| PaddleOCR Baseline | 8.85% | 91.15% | +| PaddleOCR-HyperAdjust (full dataset) | **7.72%** | **92.28%** | +| PaddleOCR-HyperAdjust (best trial) | **0.79%** | **99.21%** | -**Goal achieved:** CER < 2% (target was < 2%, result is 1.49%) +**Goal status:** CER < 2% achieved in best trial (0.79%). Full dataset shows 12.8% improvement. -### Optimal Configuration Found +### Optimal Configuration Found (GPU) ```python config_optimizada = { - "textline_orientation": True, # CRITICAL - reduces CER ~70% - "use_doc_orientation_classify": False, + "textline_orientation": True, # CRITICAL for complex layouts + "use_doc_orientation_classify": True, # Improves document orientation "use_doc_unwarping": False, - "text_det_thresh": 0.4690, - "text_det_box_thresh": 0.5412, + "text_det_thresh": 0.0462, # -0.52 correlation with CER + "text_det_box_thresh": 0.4862, "text_det_unclip_ratio": 0.0, - "text_rec_score_thresh": 0.6350, + "text_rec_score_thresh": 0.5658, } ``` ### Key Findings -1. `textline_orientation=True` is the most impactful parameter (reduces CER by 69.7%) -2. `text_det_thresh` has -0.52 correlation with CER; values < 0.1 cause catastrophic failures -3. Document correction modules (`use_doc_orientation_classify`, `use_doc_unwarping`) are unnecessary for digital PDFs +1. `textline_orientation=True` is critical for documents with mixed layouts +2. `use_doc_orientation_classify=True` improves document orientation detection in GPU config +3. `text_det_thresh` has -0.52 correlation with CER; values < 0.01 cause catastrophic failures +4. `use_doc_unwarping=False` is optimal for digital PDFs (unnecessary processing) ## Repository Structure @@ -99,13 +101,18 @@ The template (`plantilla_individual.pdf`) requires **5 chapters**. The docs/ fil ## Important Data Files -### Results CSV Files -- `src/raytune_paddle_subproc_results_20251207_192320.csv` - 64 Ray Tune trials with configs and metrics (PRIMARY DATA SOURCE) +### Results CSV Files (GPU - PRIMARY) +- `src/results/raytune_paddle_results_20260119_122609.csv` - 64 Ray Tune trials PaddleOCR GPU (PRIMARY) +- `src/results/raytune_easyocr_results_20260119_120204.csv` - 64 Ray Tune trials EasyOCR GPU +- `src/results/raytune_doctr_results_20260119_121445.csv` - 64 Ray Tune trials DocTR GPU -### Key Notebooks -- `src/paddle_ocr_fine_tune_unir_raytune.ipynb` - Main Ray Tune experiment -- `src/prepare_dataset.ipynb` - PDF to image/text conversion -- `ocr_benchmark_notebook.ipynb` - EasyOCR vs PaddleOCR vs DocTR comparison +### Results CSV Files (CPU - time reference only) +- `src/raytune_paddle_subproc_results_20251207_192320.csv` - CPU execution for time comparison (69.4s/page vs 0.84s/page GPU) + +### Key Scripts +- `src/run_tuning.py` - Main Ray Tune optimization script +- `src/raytune/raytune_ocr.py` - Ray Tune utilities and search spaces +- `src/paddle_ocr/paddle_ocr_tuning_rest.py` - PaddleOCR REST API ## Technical Stack @@ -128,13 +135,13 @@ The template (`plantilla_individual.pdf`) requires **5 chapters**. The docs/ fil ### Priority Tasks 1. **Validate on other document types** - Test optimal config on invoices, forms, contracts -2. **Expand dataset** - Current dataset has only 24 pages +2. **Use larger tuning subset** - Current 5 pages caused overfitting; recommend 15-20 pages 3. **Create presentation slides** - For thesis defense 4. **Final document review** - Open in Word, update indices (Ctrl+A, F9), verify formatting ### Optional Extensions - Explore `text_det_unclip_ratio` parameter (was fixed at 0.0) -- Compare with actual fine-tuning (if GPU access obtained) +- Compare with actual fine-tuning - Multi-objective optimization (CER + WER + inference time) ## Thesis Document Generation diff --git a/docs/00_resumen.md b/docs/00_resumen.md index 9ba0f09..de1ce36 100644 --- a/docs/00_resumen.md +++ b/docs/00_resumen.md @@ -1,12 +1,12 @@ # Resumen -El presente Trabajo Fin de Máster aborda la optimización de sistemas de Reconocimiento Óptico de Caracteres (OCR) basados en inteligencia artificial para documentos en español, específicamente en un entorno con recursos computacionales limitados donde el fine-tuning de modelos no es viable. El objetivo principal es identificar la configuración óptima de hiperparámetros que maximice la precisión del reconocimiento de texto sin requerir entrenamiento adicional de los modelos. +El presente Trabajo Fin de Máster aborda la optimización de sistemas de Reconocimiento Óptico de Caracteres (OCR) basados en inteligencia artificial para documentos en español. El objetivo principal es identificar la configuración óptima de hiperparámetros que maximice la precisión del reconocimiento de texto sin requerir fine-tuning de los modelos base. -Se realizó un estudio comparativo de tres soluciones OCR de código abierto: EasyOCR, PaddleOCR (PP-OCRv5) y DocTR, evaluando su rendimiento mediante las métricas estándar CER (Character Error Rate) y WER (Word Error Rate) sobre un corpus de documentos académicos en español. Tras identificar PaddleOCR como la solución más prometedora, se procedió a una optimización sistemática de hiperparámetros utilizando Ray Tune con el algoritmo de búsqueda Optuna, ejecutando 64 configuraciones diferentes. +Se realizó un estudio comparativo de tres soluciones OCR de código abierto: EasyOCR, PaddleOCR (PP-OCRv5) y DocTR, evaluando su rendimiento mediante las métricas estándar CER (Character Error Rate) y WER (Word Error Rate) sobre un corpus de 45 páginas de documentos académicos en español. Tras identificar PaddleOCR como la solución más prometedora, se procedió a una optimización sistemática de hiperparámetros utilizando Ray Tune con el algoritmo de búsqueda Optuna, ejecutando 64 configuraciones diferentes con aceleración GPU (NVIDIA RTX 3060). -Los resultados demuestran que la optimización de hiperparámetros logró una mejora significativa del rendimiento: el CER se redujo de 7.78% a 1.49% (mejora del 80.9% en reducción de errores), alcanzando una precisión de caracteres del 98.51%. El hallazgo más relevante fue que el parámetro `textline_orientation` (clasificación de orientación de línea de texto) tiene un impacto crítico, reduciendo el CER en un 69.7% cuando está habilitado. Adicionalmente, se identificó que el umbral de detección de píxeles (`text_det_thresh`) presenta una correlación negativa fuerte (-0.52) con el error, siendo el parámetro continuo más influyente. +Los resultados demuestran que la optimización de hiperparámetros logró mejoras significativas: el mejor trial individual alcanzó un CER de 0.79% (precisión del 99.21%), cumpliendo el objetivo de CER < 2%. Al validar la configuración optimizada sobre el dataset completo de 45 páginas, se obtuvo una mejora del 12.8% en CER (de 8.85% a 7.72%). El hallazgo más relevante fue que el parámetro `textline_orientation` (clasificación de orientación de línea de texto) tiene un impacto crítico en el rendimiento. Adicionalmente, se identificó que el umbral de detección (`text_det_thresh`) presenta una correlación negativa moderada (-0.52) con el error. -Este trabajo demuestra que es posible obtener mejoras sustanciales en sistemas OCR mediante optimización de hiperparámetros, ofreciendo una alternativa práctica al fine-tuning cuando los recursos computacionales son limitados. +Este trabajo demuestra que la optimización de hiperparámetros es una alternativa viable al fine-tuning, especialmente útil cuando se dispone de modelos preentrenados para el idioma objetivo. La infraestructura dockerizada desarrollada permite reproducir los experimentos y facilita la evaluación sistemática de configuraciones OCR. **Palabras clave:** OCR, Reconocimiento Óptico de Caracteres, PaddleOCR, Optimización de Hiperparámetros, Ray Tune, Procesamiento de Documentos, Inteligencia Artificial @@ -14,12 +14,12 @@ Este trabajo demuestra que es posible obtener mejoras sustanciales en sistemas O # Abstract -This Master's Thesis addresses the optimization of Artificial Intelligence-based Optical Character Recognition (OCR) systems for Spanish documents, specifically in a resource-constrained environment where model fine-tuning is not feasible. The main objective is to identify the optimal hyperparameter configuration that maximizes text recognition accuracy without requiring additional model training. +This Master's Thesis addresses the optimization of Artificial Intelligence-based Optical Character Recognition (OCR) systems for Spanish documents. The main objective is to identify the optimal hyperparameter configuration that maximizes text recognition accuracy without requiring fine-tuning of the base models. -A comparative study of three open-source OCR solutions was conducted: EasyOCR, PaddleOCR (PP-OCRv5), and DocTR, evaluating their performance using standard CER (Character Error Rate) and WER (Word Error Rate) metrics on a corpus of academic documents in Spanish. After identifying PaddleOCR as the most promising solution, systematic hyperparameter optimization was performed using Ray Tune with the Optuna search algorithm, executing 64 different configurations. +A comparative study of three open-source OCR solutions was conducted: EasyOCR, PaddleOCR (PP-OCRv5), and DocTR, evaluating their performance using standard CER (Character Error Rate) and WER (Word Error Rate) metrics on a corpus of 45 pages of academic documents in Spanish. After identifying PaddleOCR as the most promising solution, systematic hyperparameter optimization was performed using Ray Tune with the Optuna search algorithm, executing 64 different configurations with GPU acceleration (NVIDIA RTX 3060). -Results demonstrate that hyperparameter optimization achieved significant performance improvement: CER was reduced from 7.78% to 1.49% (80.9% error reduction), achieving 98.51% character accuracy. The most relevant finding was that the `textline_orientation` parameter (text line orientation classification) has a critical impact, reducing CER by 69.7% when enabled. Additionally, the pixel detection threshold (`text_det_thresh`) was found to have a strong negative correlation (-0.52) with error, being the most influential continuous parameter. +Results demonstrate that hyperparameter optimization achieved significant improvements: the best individual trial reached a CER of 0.79% (99.21% accuracy), meeting the CER < 2% objective. When validating the optimized configuration on the full 45-page dataset, a 12.8% CER improvement was obtained (from 8.85% to 7.72%). The most relevant finding was that the `textline_orientation` parameter (text line orientation classification) has a critical impact on performance. Additionally, the detection threshold (`text_det_thresh`) was found to have a moderate negative correlation (-0.52) with error. -This work demonstrates that substantial improvements in OCR systems can be obtained through hyperparameter optimization, offering a practical alternative to fine-tuning when computational resources are limited. +This work demonstrates that hyperparameter optimization is a viable alternative to fine-tuning, especially useful when pre-trained models for the target language are available. The dockerized infrastructure developed enables experiment reproducibility and facilitates systematic evaluation of OCR configurations. **Keywords:** OCR, Optical Character Recognition, PaddleOCR, Hyperparameter Optimization, Ray Tune, Document Processing, Artificial Intelligence diff --git a/docs/01_introduccion.md b/docs/01_introduccion.md index 8db0086..a94c652 100644 --- a/docs/01_introduccion.md +++ b/docs/01_introduccion.md @@ -1,6 +1,6 @@ # Introducción -Este capítulo presenta la motivación del trabajo, identificando el problema a resolver y justificando su relevancia. Se plantea la pregunta de investigación central y se describe la estructura del documento. +¿Es posible mejorar significativamente un sistema OCR sin reentrenarlo? Esta pregunta, aparentemente simple, encierra un desafío práctico que afecta a investigadores, instituciones educativas y empresas que necesitan digitalizar documentos pero carecen de los recursos para realizar fine-tuning de modelos neuronales. A lo largo de este capítulo se desarrolla la motivación del trabajo, se identifica el problema a resolver y se plantean las preguntas de investigación que guiarán el desarrollo experimental. ## Motivación @@ -62,7 +62,7 @@ Esta oportunidad se ve reforzada por la disponibilidad de frameworks modernos de ### Formulación del problema -El problema central que aborda este trabajo puede formularse de la siguiente manera: +Las observaciones anteriores conducen a formular el problema central de este trabajo: > ¿Es posible mejorar significativamente el rendimiento de modelos OCR preentrenados para documentos en español mediante la optimización sistemática de hiperparámetros, sin requerir fine-tuning ni recursos GPU? @@ -118,15 +118,11 @@ La relevancia de este problema radica en su aplicabilidad inmediata. Una metodol ## Estructura del trabajo -El presente documento se organiza en los siguientes capítulos: +El documento sigue una estructura que refleja el proceso investigador. Tras esta introducción, el **Capítulo 2** sitúa el trabajo en su contexto técnico, revisando las tecnologías OCR basadas en aprendizaje profundo —desde las arquitecturas de detección hasta los modelos de reconocimiento— y los trabajos previos en optimización de estos sistemas. -**Capítulo 2 - Contexto y Estado del Arte**: Se presenta una revisión de las tecnologías OCR basadas en aprendizaje profundo, incluyendo las arquitecturas de detección y reconocimiento de texto, así como los trabajos previos en optimización de estos sistemas. +El **Capítulo 3** traduce las preguntas de investigación en objetivos concretos siguiendo la metodología SMART, y describe con detalle el enfoque experimental: preparación del dataset, métricas de evaluación y configuración del proceso de optimización con Ray Tune y Optuna. -**Capítulo 3 - Objetivos y Metodología**: Se definen los objetivos SMART del trabajo y se describe la metodología experimental seguida, incluyendo la preparación del dataset, las métricas de evaluación y el proceso de optimización con Ray Tune. +El núcleo del trabajo se desarrolla en el **Capítulo 4**, que presenta el estudio comparativo y la optimización de hiperparámetros estructurados en tres fases: planteamiento de la comparativa con evaluación de EasyOCR, PaddleOCR y DocTR; desarrollo de la optimización mediante 64 trials con Ray Tune; y análisis crítico de los resultados obtenidos. -**Capítulo 4 - Desarrollo Específico de la Contribución**: Este capítulo presenta el desarrollo completo del estudio comparativo y la optimización de hiperparámetros de sistemas OCR, estructurado en tres secciones: (4.1) planteamiento de la comparativa con la evaluación de EasyOCR, PaddleOCR y DocTR; (4.2) desarrollo de la comparativa con la optimización de hiperparámetros mediante Ray Tune; y (4.3) discusión y análisis de resultados. - -**Capítulo 5 - Conclusiones y Trabajo Futuro**: Se resumen las contribuciones del trabajo, se discute el grado de cumplimiento de los objetivos y se proponen líneas de trabajo futuro. - -**Anexos**: Se incluye el enlace al repositorio de código fuente y datos, así como tablas completas de resultados experimentales. +Finalmente, el **Capítulo 5** sintetiza las contribuciones, evalúa el grado de cumplimiento de los objetivos y propone líneas de trabajo futuro. Los **Anexos** proporcionan acceso al repositorio de código fuente y datos, así como tablas detalladas de resultados experimentales. diff --git a/docs/02_contexto_estado_arte.md b/docs/02_contexto_estado_arte.md index 048ec7b..bda02ce 100644 --- a/docs/02_contexto_estado_arte.md +++ b/docs/02_contexto_estado_arte.md @@ -1,6 +1,6 @@ # Contexto y estado del arte -Este capítulo presenta el marco teórico y tecnológico en el que se desarrolla el presente trabajo. Se revisan los fundamentos del Reconocimiento Óptico de Caracteres (OCR), la evolución de las técnicas basadas en aprendizaje profundo, las principales soluciones de código abierto disponibles y los trabajos previos relacionados con la optimización de sistemas OCR. +Para comprender el alcance y las decisiones tomadas en este trabajo, es necesario situarlo en su contexto tecnológico. El Reconocimiento Óptico de Caracteres ha recorrido un largo camino desde los primeros sistemas de plantillas de los años 50 hasta las sofisticadas arquitecturas de aprendizaje profundo actuales. A lo largo de este capítulo se revisan los fundamentos técnicos del OCR moderno, se analizan las principales soluciones de código abierto y se identifican los vacíos en la literatura que motivan la contribución de este trabajo. ## Contexto del problema @@ -62,6 +62,13 @@ Los sistemas OCR modernos siguen típicamente un pipeline de dos etapas principa ```mermaid --- title: "Pipeline de un sistema OCR moderno" +config: + theme: base + themeVariables: + primaryColor: "#E6F4F9" + primaryTextColor: "#404040" + primaryBorderColor: "#0098CD" + lineColor: "#0098CD" --- flowchart LR subgraph Input @@ -114,7 +121,7 @@ Las arquitecturas más utilizadas para detección de texto incluyen: **DB (Differentiable Binarization)**: Propuesto por Liao et al. (2020), DB introduce una operación de binarización diferenciable que permite entrenar end-to-end un detector de texto basado en segmentación. Esta arquitectura es la utilizada por PaddleOCR y destaca por su velocidad y precisión. -**Tabla 1.** *Comparativa de arquitecturas de detección de texto.* +**Tabla 4.** *Comparativa de arquitecturas de detección de texto.* | Arquitectura | Tipo | Salida | Fortalezas | Limitaciones | |--------------|------|--------|------------|--------------| @@ -141,7 +148,7 @@ La arquitectura CRNN consta de tres componentes: **TrOCR (Transformer-based OCR)**: Propuesto por Li et al. (2023), TrOCR utiliza un Vision Transformer (ViT) como encoder y un Transformer de lenguaje como decoder, logrando resultados estado del arte en múltiples benchmarks. -**Tabla 2.** *Comparativa de arquitecturas de reconocimiento de texto.* +**Tabla 5.** *Comparativa de arquitecturas de reconocimiento de texto.* | Arquitectura | Encoder | Decoder | Pérdida | Características | |--------------|---------|---------|---------|-----------------| @@ -286,7 +293,7 @@ El pipeline de PaddleOCR consta de tres módulos principales: PaddleOCR expone numerosos hiperparámetros que permiten ajustar el comportamiento del sistema. Los más relevantes para este trabajo son: -**Tabla 3.** *Hiperparámetros de detección de PaddleOCR.* +**Tabla 6.** *Hiperparámetros de detección de PaddleOCR.* | Parámetro | Descripción | Rango | Defecto | |-----------|-------------|-------|---------| @@ -297,7 +304,7 @@ PaddleOCR expone numerosos hiperparámetros que permiten ajustar el comportamien *Fuente: Documentación oficial de PaddleOCR (PaddlePaddle, 2024).* -**Tabla 4.** *Hiperparámetros de reconocimiento de PaddleOCR.* +**Tabla 7.** *Hiperparámetros de reconocimiento de PaddleOCR.* | Parámetro | Descripción | Rango | Defecto | |-----------|-------------|-------|---------| @@ -307,7 +314,7 @@ PaddleOCR expone numerosos hiperparámetros que permiten ajustar el comportamien *Fuente: Documentación oficial de PaddleOCR (PaddlePaddle, 2024).* -**Tabla 5.** *Hiperparámetros de preprocesamiento de PaddleOCR.* +**Tabla 8.** *Hiperparámetros de preprocesamiento de PaddleOCR.* | Parámetro | Descripción | Impacto | |-----------|-------------|---------| @@ -352,7 +359,7 @@ DocTR (Document Text Recognition) es una biblioteca desarrollada por Mindee (202 #### Comparativa Detallada de Soluciones -**Tabla 6.** *Comparativa técnica de soluciones OCR de código abierto.* +**Tabla 9.** *Comparativa técnica de soluciones OCR de código abierto.* | Aspecto | EasyOCR | PaddleOCR | DocTR | |---------|---------|-----------|-------| @@ -367,7 +374,7 @@ DocTR (Document Text Recognition) es una biblioteca desarrollada por Mindee (202 *Fuente: Elaboración propia a partir de documentación oficial (2024).* -**Tabla 7.** *Comparativa de facilidad de uso.* +**Tabla 10.** *Comparativa de facilidad de uso.* | Aspecto | EasyOCR | PaddleOCR | DocTR | |---------|---------|-----------|-------| @@ -392,7 +399,7 @@ A diferencia de los parámetros del modelo (como los pesos de una red neuronal), El problema de HPO puede formalizarse como: -$$\lambda^* = \arg\min_{\lambda \in \Lambda} \mathcal{L}(M_\lambda, D_{val})$$ +$$\lambda^* = \operatorname{argmin}_{\lambda \in \Lambda} \mathcal{L}(M_\lambda, D_{val})$$ Donde: - $\lambda$ es un vector de hiperparámetros @@ -487,6 +494,13 @@ La combinación de Ray Tune con OptunaSearch permite: ```mermaid --- title: "Ciclo de optimización con Ray Tune y Optuna" +config: + theme: base + themeVariables: + primaryColor: "#E6F4F9" + primaryTextColor: "#404040" + primaryBorderColor: "#0098CD" + lineColor: "#0098CD" --- flowchart LR A["Espacio deResumen
El presente Trabajo Fin de Máster aborda la optimización de sistemas de Reconocimiento Óptico de Caracteres (OCR) basados en inteligencia artificial para documentos en español, específicamente en un entorno con recursos computacionales limitados donde el fine-tuning de modelos no es viable. El objetivo principal es identificar la configuración óptima de hiperparámetros que maximice la precisión del reconocimiento de texto sin requerir entrenamiento adicional de los modelos.
+ Resumen El presente Trabajo Fin de Máster aborda la optimización de sistemas de Reconocimiento Óptico de Caracteres (OCR) basados en inteligencia artificial para documentos en español. El objetivo principal es identificar la configuración óptima de hiperparámetros que maximice la precisión del reconocimiento de texto sin requerir fine-tuning de los modelos base.
-Se realizó un estudio comparativo de tres soluciones OCR de código abierto: EasyOCR, PaddleOCR (PP-OCRv5) y DocTR, evaluando su rendimiento mediante las métricas estándar CER (Character Error Rate) y WER (Word Error Rate) sobre un corpus de documentos académicos en español. Tras identificar PaddleOCR como la solución más prometedora, se procedió a una optimización sistemática de hiperparámetros utilizando Ray Tune con el algoritmo de búsqueda Optuna, ejecutando 64 configuraciones diferentes.
+Se realizó un estudio comparativo de tres soluciones OCR de código abierto: EasyOCR, PaddleOCR (PP-OCRv5) y DocTR, evaluando su rendimiento mediante las métricas estándar CER (Character Error Rate) y WER (Word Error Rate) sobre un corpus de 45 páginas de documentos académicos en español. Tras identificar PaddleOCR como la solución más prometedora, se procedió a una optimización sistemática de hiperparámetros utilizando Ray Tune con el algoritmo de búsqueda Optuna, ejecutando 64 configuraciones diferentes con aceleración GPU (NVIDIA RTX 3060).
-Los resultados demuestran que la optimización de hiperparámetros logró una mejora significativa del rendimiento: el CER se redujo de 7.78% a 1.49% (mejora del 80.9% en reducción de errores), alcanzando una precisión de caracteres del 98.51%. El hallazgo más relevante fue que el parámetro `textline_orientation` (clasificación de orientación de línea de texto) tiene un impacto crítico, reduciendo el CER en un 69.7% cuando está habilitado. Adicionalmente, se identificó que el umbral de detección de píxeles (`text_det_thresh`) presenta una correlación negativa fuerte (-0.52) con el error, siendo el parámetro continuo más influyente.
+Los resultados demuestran que la optimización de hiperparámetros logró mejoras significativas: el mejor trial individual alcanzó un CER de 0.79% (precisión del 99.21%), cumpliendo el objetivo de CER < 2%. Al validar la configuración optimizada sobre el dataset completo de 45 páginas, se obtuvo una mejora del 12.8% en CER (de 8.85% a 7.72%). El hallazgo más relevante fue que el parámetro `textline_orientation` (clasificación de orientación de línea de texto) tiene un impacto crítico en el rendimiento. Adicionalmente, se identificó que el umbral de detección (`text_det_thresh`) presenta una correlación negativa moderada (-0.52) con el error.
-Este trabajo demuestra que es posible obtener mejoras sustanciales en sistemas OCR mediante optimización de hiperparámetros, ofreciendo una alternativa práctica al fine-tuning cuando los recursos computacionales son limitados.
Palabras clave: OCR, Reconocimiento Óptico de Caracteres, PaddleOCR, Optimización de Hiperparámetros, Ray Tune, Procesamiento de Documentos, Inteligencia Artificial
Abstract
This Master's Thesis addresses the optimization of Artificial Intelligence-based Optical Character Recognition (OCR) systems for Spanish documents, specifically in a resource-constrained environment where model fine-tuning is not feasible. The main objective is to identify the optimal hyperparameter configuration that maximizes text recognition accuracy without requiring additional model training.
+ Abstract This Master's Thesis addresses the optimization of Artificial Intelligence-based Optical Character Recognition (OCR) systems for Spanish documents. The main objective is to identify the optimal hyperparameter configuration that maximizes text recognition accuracy without requiring fine-tuning of the base models.
-A comparative study of three open-source OCR solutions was conducted: EasyOCR, PaddleOCR (PP-OCRv5), and DocTR, evaluating their performance using standard CER (Character Error Rate) and WER (Word Error Rate) metrics on a corpus of academic documents in Spanish. After identifying PaddleOCR as the most promising solution, systematic hyperparameter optimization was performed using Ray Tune with the Optuna search algorithm, executing 64 different configurations.
+A comparative study of three open-source OCR solutions was conducted: EasyOCR, PaddleOCR (PP-OCRv5), and DocTR, evaluating their performance using standard CER (Character Error Rate) and WER (Word Error Rate) metrics on a corpus of 45 pages of academic documents in Spanish. After identifying PaddleOCR as the most promising solution, systematic hyperparameter optimization was performed using Ray Tune with the Optuna search algorithm, executing 64 different configurations with GPU acceleration (NVIDIA RTX 3060).
-Results demonstrate that hyperparameter optimization achieved significant performance improvement: CER was reduced from 7.78% to 1.49% (80.9% error reduction), achieving 98.51% character accuracy. The most relevant finding was that the `textline_orientation` parameter (text line orientation classification) has a critical impact, reducing CER by 69.7% when enabled. Additionally, the pixel detection threshold (`text_det_thresh`) was found to have a strong negative correlation (-0.52) with error, being the most influential continuous parameter.
+Results demonstrate that hyperparameter optimization achieved significant improvements: the best individual trial reached a CER of 0.79% (99.21% accuracy), meeting the CER < 2% objective. When validating the optimized configuration on the full 45-page dataset, a 12.8% CER improvement was obtained (from 8.85% to 7.72%). The most relevant finding was that the `textline_orientation` parameter (text line orientation classification) has a critical impact on performance. Additionally, the detection threshold (`text_det_thresh`) was found to have a moderate negative correlation (-0.52) with error.
-This work demonstrates that substantial improvements in OCR systems can be obtained through hyperparameter optimization, offering a practical alternative to fine-tuning when computational resources are limited.
Keywords: OCR, Optical Character Recognition, PaddleOCR, Hyperparameter Optimization, Ray Tune, Document Processing, Artificial Intelligence
Este capítulo presenta la motivación del trabajo, identificando el problema a resolver y justificando su relevancia. Se plantea la pregunta de investigación central y se describe la estructura del documento.
+Introducción¿Es posible mejorar significativamente un sistema OCR sin reentrenarlo? Esta pregunta, aparentemente simple, encierra un desafío práctico que afecta a investigadores, instituciones educativas y empresas que necesitan digitalizar documentos pero carecen de los recursos para realizar fine-tuning de modelos neuronales. A lo largo de este capítulo se desarrolla la motivación del trabajo, se identifica el problema a resolver y se plantean las preguntas de investigación que guiarán el desarrollo experimental.
El Reconocimiento Óptico de Caracteres (OCR) es una tecnología fundamental en la era de la digitalización documental. Su capacidad para convertir imágenes de texto en datos editables y procesables ha transformado sectores como la administración pública, el ámbito legal, la banca y la educación. Según estimaciones del sector, el mercado global de OCR alcanzó los 13.4 mil millones de dólares en 2023, con proyecciones de crecimiento continuo impulsado por la transformación digital empresarial (Grand View Research, 2023). Sin embargo, a pesar de los avances significativos impulsados por el aprendizaje profundo, la implementación práctica de sistemas OCR de alta precisión sigue presentando desafíos considerables.
La Tabla 1 resume los principales desafíos lingüísticos del OCR en español:
Tabla 1. Desafíos lingüísticos específicos del OCR en español.
-Desafío | Descripción | Impacto en OCR |
Caracteres especiales | ñ, á, é, í, ó, ú, ü, ¿, ¡ | Confusión con caracteres similares (n/ñ, a/á) |
Palabras largas | Español permite compuestos largos | Mayor probabilidad de error por carácter |
Abreviaturas | Dr., Sra., Ud., etc. | Puntos internos confunden segmentación |
Nombres propios | Tildes en apellidos (García, Martínez) | Bases de datos sin soporte Unicode |
Desafío | Descripción | Impacto en OCR |
Caracteres especiales | ñ, á, é, í, ó, ú, ü, ¿, ¡ | Confusión con caracteres similares (n/ñ, a/á) |
Palabras largas | Español permite compuestos largos | Mayor probabilidad de error por carácter |
Abreviaturas | Dr., Sra., Ud., etc. | Puntos internos confunden segmentación |
Nombres propios | Tildes en apellidos (García, Martínez) | Bases de datos sin soporte Unicode |
Fuente: Elaboración propia.
Además de los aspectos lingüísticos, los documentos académicos y administrativos en español presentan características tipográficas que complican el reconocimiento: variaciones en fuentes entre encabezados, cuerpo y notas al pie; presencia de tablas con bordes y celdas; logotipos institucionales; marcas de agua; y elementos gráficos como firmas o sellos. Estos elementos generan ruido que puede propagarse en aplicaciones downstream como la extracción de entidades nombradas o el análisis semántico.
@@ -4556,7 +4556,7 @@ mso-bidi-font-family:"Calibri Light";mso-bidi-theme-font:major-latin'>La adaptación de modelos preentrenados a dominios específicos típicamente requiere fine-tuning con datos etiquetados del dominio objetivo y recursos computacionales significativos. El fine-tuning de un modelo de reconocimiento de texto puede requerir decenas de miles de imágenes etiquetadas y días de entrenamiento en GPUs de alta capacidad. Esta barrera técnica y económica excluye a muchos investigadores y organizaciones de beneficiarse plenamente de estas tecnologías.La Tabla 2 ilustra los requisitos típicos para diferentes estrategias de mejora de OCR:
Tabla 2. Comparación de estrategias de mejora de modelos OCR.
-Estrategia | Datos requeridos | Hardware | Tiempo | Expertise |
Fine-tuning completo | >10,000 imágenes etiquetadas | GPU (≥16GB VRAM) | Días-Semanas | Alto |
Fine-tuning parcial | >1,000 imágenes etiquetadas | GPU (≥8GB VRAM) | Horas-Días | Medio-Alto |
Transfer learning | >500 imágenes etiquetadas | GPU (≥8GB VRAM) | Horas | Medio |
Optimización de hiperparámetros | <100 imágenes de validación | CPU suficiente | Horas | Bajo-Medio |
Estrategia | Datos requeridos | Hardware | Tiempo | Expertise |
Fine-tuning completo | >10,000 imágenes etiquetadas | GPU (≥16GB VRAM) | Días-Semanas | Alto |
Fine-tuning parcial | >1,000 imágenes etiquetadas | GPU (≥8GB VRAM) | Horas-Días | Medio-Alto |
Transfer learning | >500 imágenes etiquetadas | GPU (≥8GB VRAM) | Horas | Medio |
Optimización de hiperparámetros | <100 imágenes de validación | CPU suficiente | Horas | Bajo-Medio |
Fuente: Elaboración propia.
El problema central que aborda este trabajo puede formularse de la siguiente manera:
-¿Es posible mejorar significativamente el rendimiento de modelos OCR preentrenados para documentos en español mediante la optimización sistemática de hiperparámetros, sin requerir fine-tuning ni recursos GPU?
+Las observaciones anteriores conducen a formular el problema central de este trabajo:
+¿Es posible mejorar significativamente el rendimiento de modelos OCR preentrenados para documentos en español mediante la optimización sistemática de hiperparámetros, sin requerir fine-tuning ni recursos GPU?
Este planteamiento parte de una observación fundamental: los sistemas OCR modernos exponen múltiples parámetros configurables que afectan su comportamiento durante la inferencia. Estos parámetros incluyen umbrales de detección, opciones de preprocesamiento, y filtros de calidad. En la práctica habitual, estos parámetros se dejan en sus valores por defecto, asumiendo que fueron optimizados por los desarrolladores del modelo. Sin embargo, los valores por defecto representan compromisos generales que pueden no ser óptimos para dominios específicos.
Este planteamiento se descompone en las siguientes cuestiones específicas:
@@ -4581,7 +4581,7 @@ mso-bidi-font-family:"Calibri Light";mso-bidi-theme-font:major-latin'>Alcance y delimitaciónEste trabajo se centra específicamente en:
Tabla 3. Delimitación del alcance del trabajo.
-Aspecto | Dentro del alcance | Fuera del alcance |
Tipo de documento | Documentos académicos digitales (PDF) | Documentos escaneados, manuscritos |
Idioma | Español | Otros idiomas |
Modelos | EasyOCR, PaddleOCR, DocTR | Soluciones comerciales (Google Cloud Vision, AWS Textract) |
Método de mejora | Optimización de hiperparámetros | Fine-tuning, aumento de datos |
Hardware | Ejecución en CPU | Aceleración GPU |
Aspecto | Dentro del alcance | Fuera del alcance |
Tipo de documento | Documentos académicos digitales (PDF) | Documentos escaneados, manuscritos |
Idioma | Español | Otros idiomas |
Modelos | EasyOCR, PaddleOCR, DocTR | Soluciones comerciales (Google Cloud Vision, AWS Textract) |
Método de mejora | Optimización de hiperparámetros | Fine-tuning, aumento de datos |
Hardware | Ejecución en CPU | Aceleración GPU |
Fuente: Elaboración propia.
Desarrolladores de software: Quienes integran OCR en aplicaciones con restricciones de recursos, como dispositivos móviles o servidores compartidos, y necesitan maximizar el rendimiento sin costes adicionales de hardware.
El presente documento se organiza en los siguientes capítulos:
-Capítulo 2 - Contexto y Estado del Arte: Se presenta una revisión de las tecnologías OCR basadas en aprendizaje profundo, incluyendo las arquitecturas de detección y reconocimiento de texto, así como los trabajos previos en optimización de estos sistemas.
-Capítulo 3 - Objetivos y Metodología: Se definen los objetivos SMART del trabajo y se describe la metodología experimental seguida, incluyendo la preparación del dataset, las métricas de evaluación y el proceso de optimización con Ray Tune.
-Capítulo 4 - Desarrollo Específico de la Contribución: Este capítulo presenta el desarrollo completo del estudio comparativo y la optimización de hiperparámetros de sistemas OCR, estructurado en tres secciones: (4.1) planteamiento de la comparativa con la evaluación de EasyOCR, PaddleOCR y DocTR; (4.2) desarrollo de la comparativa con la optimización de hiperparámetros mediante Ray Tune; y (4.3) discusión y análisis de resultados.
-Capítulo 5 - Conclusiones y Trabajo Futuro: Se resumen las contribuciones del trabajo, se discute el grado de cumplimiento de los objetivos y se proponen líneas de trabajo futuro.
-Anexos: Se incluye el enlace al repositorio de código fuente y datos, así como tablas completas de resultados experimentales.
Este capítulo presenta el marco teórico y tecnológico en el que se desarrolla el presente trabajo. Se revisan los fundamentos del Reconocimiento Óptico de Caracteres (OCR), la evolución de las técnicas basadas en aprendizaje profundo, las principales soluciones de código abierto disponibles y los trabajos previos relacionados con la optimización de sistemas OCR.
+_Toc14106979">Para comprender el alcance y las decisiones tomadas en este trabajo, es necesario situarlo en su contexto tecnológico. El Reconocimiento Óptico de Caracteres ha recorrido un largo camino desde los primeros sistemas de plantillas de los años 50 hasta las sofisticadas arquitecturas de aprendizaje profundo actuales. A lo largo de este capítulo se revisan los fundamentos técnicos del OCR moderno, se analizan las principales soluciones de código abierto y se identifican los vacíos en la literatura que motivan la contribución de este trabajo.
El Reconocimiento Óptico de Caracteres (OCR) es el proceso de conversión de imágenes de texto manuscrito, mecanografiado o impreso en texto codificado digitalmente. Esta tecnología permite la digitalización masiva de documentos, facilitando su búsqueda, edición y almacenamiento electrónico. La tecnología OCR ha evolucionado significativamente desde sus orígenes en la década de 1950, atravesando cuatro generaciones claramente diferenciadas:
@@ -4637,7 +4635,7 @@ _Toc14106979">Pipeline Moderno de OCRLos sistemas OCR modernos siguen típicamente un pipeline de dos etapas principales, precedidas opcionalmente por una fase de preprocesamiento:
Figura 1. Pipeline de un sistema OCR moderno
-

Fuente: Elaboración propia.
DB (Differentiable Binarization): Propuesto por Liao et al. (2020), DB introduce una operación de binarización diferenciable que permite entrenar end-to-end un detector de texto basado en segmentación. Esta arquitectura es la utilizada por PaddleOCR y destaca por su velocidad y precisión.
Tabla 4. Comparativa de arquitecturas de detección de texto.
-Arquitectura | Tipo | Salida | Fortalezas | Limitaciones |
EAST | Single-shot | Cuadriláteros rotados | Rápido, simple | Dificultad con texto curvo |
CRAFT | Bottom-up | Polígonos de palabra | Robusto a espaciado | Mayor coste computacional |
DB | Segmentación | Polígonos arbitrarios | Rápido, preciso | Sensible a parámetros |
Arquitectura | Tipo | Salida | Fortalezas | Limitaciones |
EAST | Single-shot | Cuadriláteros rotados | Rápido, simple | Dificultad con texto curvo |
CRAFT | Bottom-up | Polígonos de palabra | Robusto a espaciado | Mayor coste computacional |
DB | Segmentación | Polígonos arbitrarios | Rápido, preciso | Sensible a parámetros |
Fuente: Elaboración propia.
TrOCR (Transformer-based OCR): Propuesto por Li et al. (2023), TrOCR utiliza un Vision Transformer (ViT) como encoder y un Transformer de lenguaje como decoder, logrando resultados estado del arte en múltiples benchmarks.
Tabla 5. Comparativa de arquitecturas de reconocimiento de texto.
-Arquitectura | Encoder | Decoder | Pérdida | Características |
CRNN | CNN | BiLSTM | CTC | Rápido, robusto |
SVTR | ViT | Linear | CTC | Sin recurrencia |
Attention-based | CNN | LSTM+Attn | Cross-entropy | Flexible longitud |
TrOCR | ViT | Transformer | Cross-entropy | Estado del arte |
Arquitectura | Encoder | Decoder | Pérdida | Características |
CRNN | CNN | BiLSTM | CTC | Rápido, robusto |
SVTR | ViT | Linear | CTC | Sin recurrencia |
Attention-based | CNN | LSTM+Attn | Cross-entropy | Flexible longitud |
TrOCR | ViT | Transformer | Cross-entropy | Estado del arte |
Fuente: Elaboración propia.
PaddleOCR expone numerosos hiperparámetros que permiten ajustar el comportamiento del sistema. Los más relevantes para este trabajo son:
Tabla 6. Hiperparámetros de detección de PaddleOCR.
-Parámetro | Descripción | Rango | Defecto |
text_det_thresh | Umbral de probabilidad para píxeles de texto | [0.0, 1.0] | 0.3 |
text_det_box_thresh | Umbral de confianza para cajas detectadas | [0.0, 1.0] | 0.6 |
text_det_unclip_ratio | Factor de expansión de cajas detectadas | [0.0, 3.0] | 1.5 |
text_det_limit_side_len | Tamaño máximo del lado de imagen | [320, 2560] | 960 |
Parámetro | Descripción | Rango | Defecto |
text_det_thresh | Umbral de probabilidad para píxeles de texto | [0.0, 1.0] | 0.3 |
text_det_box_thresh | Umbral de confianza para cajas detectadas | [0.0, 1.0] | 0.6 |
text_det_unclip_ratio | Factor de expansión de cajas detectadas | [0.0, 3.0] | 1.5 |
text_det_limit_side_len | Tamaño máximo del lado de imagen | [320, 2560] | 960 |
Fuente: Elaboración propia.
Tabla 7. Hiperparámetros de reconocimiento de PaddleOCR.
-Parámetro | Descripción | Rango | Defecto |
text_rec_score_thresh | Umbral de confianza para resultados | [0.0, 1.0] | 0.5 |
use_textline_orientation | Activar clasificación de orientación de línea | {True, False} | False |
rec_batch_size | Tamaño de batch para reconocimiento | [1, 64] | 6 |
Parámetro | Descripción | Rango | Defecto |
text_rec_score_thresh | Umbral de confianza para resultados | [0.0, 1.0] | 0.5 |
use_textline_orientation | Activar clasificación de orientación de línea | {True, False} | False |
rec_batch_size | Tamaño de batch para reconocimiento | [1, 64] | 6 |
Fuente: Elaboración propia.
Tabla 8. Hiperparámetros de preprocesamiento de PaddleOCR.
-Parámetro | Descripción | Impacto |
use_doc_orientation_classify | Clasificación de orientación del documento | Alto para documentos escaneados |
use_doc_unwarping | Corrección de deformación/curvatura | Alto para fotos de documentos |
use_angle_cls | Clasificador de ángulo 0°/180° | Medio para documentos rotados |
Parámetro | Descripción | Impacto |
use_doc_orientation_classify | Clasificación de orientación del documento | Alto para documentos escaneados |
use_doc_unwarping | Corrección de deformación/curvatura | Alto para fotos de documentos |
use_angle_cls | Clasificador de ángulo 0°/180° | Medio para documentos rotados |
Fuente: Elaboración propia.
Fortalezas de PaddleOCR:
@@ -4792,11 +4790,11 @@ _Toc14106979">· Menos opciones de modelos preentrenados para idiomas no inglesesTabla 9. Comparativa técnica de soluciones OCR de código abierto.
-Aspecto | EasyOCR | PaddleOCR | DocTR |
Framework | PyTorch | PaddlePaddle | TF/PyTorch |
Detector | CRAFT | DB | DB/LinkNet |
Reconocedor | CRNN | SVTR/CRNN | CRNN/SAR/ViTSTR |
Idiomas | 80+ | 80+ | 9 |
Configurabilidad | Baja | Alta | Media |
Documentación | Media | Alta (CN) | Alta (EN) |
Actividad | Media | Alta | Media |
Licencia | Apache 2.0 | Apache 2.0 | Apache 2.0 |
Aspecto | EasyOCR | PaddleOCR | DocTR |
Framework | PyTorch | PaddlePaddle | TF/PyTorch |
Detector | CRAFT | DB | DB/LinkNet |
Reconocedor | CRNN | SVTR/CRNN | CRNN/SAR/ViTSTR |
Idiomas | 80+ | 80+ | 9 |
Configurabilidad | Baja | Alta | Media |
Documentación | Media | Alta (CN) | Alta (EN) |
Actividad | Media | Alta | Media |
Licencia | Apache 2.0 | Apache 2.0 | Apache 2.0 |
Fuente: Elaboración propia.
Tabla 10. Comparativa de facilidad de uso.
-Aspecto | EasyOCR | PaddleOCR | DocTR |
Instalación | pip install | pip install | pip install |
Líneas para OCR básico | 3 | 5 | 6 |
GPU requerida | Opcional | Opcional | Opcional |
Memoria mínima | 2 GB | 4 GB | 4 GB |
Aspecto | EasyOCR | PaddleOCR | DocTR |
Instalación | pip install | pip install | pip install |
Líneas para OCR básico | 3 | 5 | 6 |
GPU requerida | Opcional | Opcional | Opcional |
Memoria mínima | 2 GB | 4 GB | 4 GB |
Fuente: Elaboración propia.
· Umbrales de decisión en tiempo de inferencia (relevante para este trabajo)
El problema de HPO puede formalizarse como:
- +Donde:
· es un vector de hiperparámetros
· es el espacio de búsqueda
@@ -4880,7 +4878,7 @@ Configuraciones con alta probabilidad bajoLa motivación presentada en el capítulo anterior se traduce ahora en objetivos concretos y medibles. Siguiendo la metodología SMART propuesta por Doran (1981), se define un objetivo general que guía el trabajo y cinco objetivos específicos que lo descomponen en metas alcanzables. La segunda parte del capítulo describe la metodología experimental diseñada para alcanzar estos objetivos.
Optimizar el rendimiento de PaddleOCR para documentos académicos en español mediante ajuste de hiperparámetros, alcanzando un CER inferior al 2% sin requerir fine-tuning del modelo ni recursos GPU dedicados.
+Optimizar el rendimiento de PaddleOCR para documentos académicos en español mediante ajuste de hiperparámetros, alcanzando un CER inferior al 2% sin requerir fine-tuning del modelo.
Tabla 13. Justificación SMART del objetivo general.
-Criterio | Cumplimiento |
Específico (S) | Se define claramente qué se quiere lograr: optimizar PaddleOCR mediante ajuste de hiperparámetros para documentos en español |
Medible (M) | Se establece una métrica cuantificable: CER < 2% |
Alcanzable (A) | Es viable dado que: (1) PaddleOCR permite configuración de hiperparámetros, (2) Ray Tune posibilita búsqueda automatizada, (3) No se requiere GPU |
Relevante (R) | El impacto es demostrable: mejora la extracción de texto en documentos académicos sin costes adicionales de infraestructura |
Temporal (T) | El plazo es un cuatrimestre, correspondiente al TFM |
Criterio | Cumplimiento |
Específico (S) | Se define claramente qué se quiere lograr: optimizar PaddleOCR mediante ajuste de hiperparámetros para documentos en español |
Medible (M) | Se establece una métrica cuantificable: CER < 2% |
Alcanzable (A) | Es viable dado que: (1) PaddleOCR permite configuración de hiperparámetros, (2) Ray Tune posibilita búsqueda automatizada, (3) Aceleración GPU disponible para experimentación eficiente |
Relevante (R) | El impacto es demostrable: mejora la extracción de texto en documentos académicos sin costes adicionales de infraestructura |
Temporal (T) | El plazo es un cuatrimestre, correspondiente al TFM |
Fuente: Elaboración propia.
Evaluar el rendimiento base de EasyOCR, PaddleOCR y DocTR en documentos académicos en español, utilizando CER y WER como métricas, para seleccionar el modelo más prometedor.
+Evaluar el rendimiento base de EasyOCR, PaddleOCR y DocTR en documentos académicos en español, utilizando CER y WER como métricas, para seleccionar el modelo más prometedor.
Construir un dataset estructurado de imágenes de documentos académicos en español con su texto de referencia (ground truth) extraído del PDF original.
+Construir un dataset estructurado de imágenes de documentos académicos en español con su texto de referencia (ground truth) extraído del PDF original.
Analizar la correlación entre los hiperparámetros de PaddleOCR y las métricas de error para identificar los parámetros con mayor impacto en el rendimiento.
+Analizar la correlación entre los hiperparámetros de PaddleOCR y las métricas de error para identificar los parámetros con mayor impacto en el rendimiento.
Ejecutar una búsqueda automatizada de hiperparámetros utilizando Ray Tune con Optuna, evaluando al menos 50 configuraciones diferentes.
+Ejecutar una búsqueda automatizada de hiperparámetros utilizando Ray Tune con Optuna, evaluando al menos 50 configuraciones diferentes.
Comparar el rendimiento de la configuración baseline versus la configuración optimizada sobre el dataset completo, documentando la mejora obtenida.
+Comparar el rendimiento de la configuración baseline versus la configuración optimizada sobre el dataset completo, documentando la mejora obtenida.
La metodología se estructura en cinco fases secuenciales, cada una de las cuales produce resultados que alimentan la siguiente. Desde la preparación del dataset hasta la validación final, el proceso sigue un diseño experimental que permite reproducir y verificar cada paso.
Figura 3. Fases de la metodología experimental
-

Fuente: Elaboración propia.
Descripción de las fases:
@@ -4978,7 +4972,7 @@ concretos y metodología de trabajo - Método: page.get_text("dict") de PyMuPDF - Preservación de estructura de líneas - Tratamiento de texto vertical/marginal - Normalización de espacios y saltos de líneaFigura 4. Estructura del dataset de evaluación
-

Fuente: Elaboración propia.
Tabla 14. Modelos OCR evaluados en el benchmark inicial.
-Modelo | Versión | Configuración |
EasyOCR | - | Idiomas: ['es', 'en'] |
PaddleOCR | PP-OCRv5 | Modelos server_det + server_rec |
DocTR | - | db_resnet50 + sar_resnet31 |
Modelo | Versión | Configuración |
EasyOCR | - | Idiomas: ['es', 'en'] |
PaddleOCR | PP-OCRv5 | Modelos server_det + server_rec |
DocTR | - | db_resnet50 + sar_resnet31 |
Fuente: Elaboración propia.
Tabla 15. Hiperparámetros seleccionados para optimización.
-Parámetro | Tipo | Rango/Valores | Descripción |
use_doc_orientation_classify | Booleano | [True, False] | Clasificación de orientación del documento |
use_doc_unwarping | Booleano | [True, False] | Corrección de deformación del documento |
textline_orientation | Booleano | [True, False] | Clasificación de orientación de línea de texto |
text_det_thresh | Continuo | [0.0, 0.7] | Umbral de detección de píxeles de texto |
text_det_box_thresh | Continuo | [0.0, 0.7] | Umbral de caja de detección |
text_det_unclip_ratio | Fijo | 0.0 | Coeficiente de expansión (fijado) |
text_rec_score_thresh | Continuo | [0.0, 0.7] | Umbral de confianza de reconocimiento |
Parámetro | Tipo | Rango/Valores | Descripción |
use_doc_orientation_classify | Booleano | [True, False] | Clasificación de orientación del documento |
use_doc_unwarping | Booleano | [True, False] | Corrección de deformación del documento |
textline_orientation | Booleano | [True, False] | Clasificación de orientación de línea de texto |
text_det_thresh | Continuo | [0.0, 0.7] | Umbral de detección de píxeles de texto |
text_det_box_thresh | Continuo | [0.0, 0.7] | Umbral de caja de detección |
text_det_unclip_ratio | Fijo | 0.0 | Coeficiente de expansión (fijado) |
text_rec_score_thresh | Continuo | [0.0, 0.7] | Umbral de confianza de reconocimiento |
Fuente: Elaboración propia.
Los servicios se orquestan mediante Docker Compose (src/docker-compose.tuning.*.yml):
-El servicio OCR expone una API REST que retorna métricas en formato JSON: 1. Baseline: Ejecución con configuración por defecto de PaddleOCR 2. Optimizado: Ejecución con mejor configuración encontrada 3. Comparación: Evaluación sobre las 24 páginas del dataset completo 3. Comparación: Evaluación sobre las 45 páginas del dataset completo 4. Métricas reportadas: CER, WER, tiempo de procesamiento Tabla 16. Especificaciones de hardware del entorno de desarrollo. Componente Especificación CPU AMD Ryzen 7 5800H RAM 16 GB DDR4 GPU NVIDIA RTX 3060 Laptop (5.66 GB VRAM) Almacenamiento SSD Componente Especificación CPU AMD Ryzen 7 5800H RAM 16 GB DDR4 GPU NVIDIA RTX 3060 Laptop (5.66 GB VRAM) Almacenamiento SSD Fuente: Elaboración propia. Tabla 17. Versiones de software utilizadas. Componente Versión Sistema Operativo Ubuntu 24.04.3 LTS Python 3.12.3 PaddleOCR 3.3.2 PaddlePaddle 3.2.2 Ray 2.52.1 Optuna 4.7.0 Componente Versión Sistema Operativo Ubuntu 24.04.3 LTS Python 3.12.3 PaddleOCR 3.3.2 PaddlePaddle 3.2.2 Ray 2.52.1 Optuna 4.7.0 Fuente: Elaboración propia. La decisión de ejecutar los experimentos en hardware local en lugar de utilizar servicios cloud se fundamenta en un análisis de costos y beneficios operativos. Tabla 18. Costos de GPU en plataformas cloud. Plataforma GPU Costo/Hora Costo Mensual AWS EC2 g4dn.xlarge NVIDIA T4 (16 GB) $0.526 ~$384 Google Colab Pro T4/P100 ~$1.30 $10 + CU extras Google Colab Pro+ T4/V100/A100 ~$1.30 $50 + CU extras Plataforma GPU Costo/Hora Costo Mensual AWS EC2 g4dn.xlarge NVIDIA T4 (16 GB) $0.526 ~$384 Google Colab Pro T4/P100 ~$1.30 $10 + CU extras Google Colab Pro+ T4/V100/A100 ~$1.30 $50 + CU extras Fuente: Elaboración propia. Para las tareas específicas de este proyecto, los costos estimados en cloud serían: Tabla 19. Análisis de costos del proyecto en plataformas cloud. Tarea Tiempo GPU Costo AWS Costo Colab Pro Ajuste hiperparámetros (64×3 trials) ~3 horas ~$1.58 ~$3.90 Evaluación completa (45 páginas) ~5 min ~$0.04 ~$0.11 Desarrollo y depuración (20 horas/mes) 20 horas ~$10.52 ~$26.00 Tarea Tiempo GPU Costo AWS Costo Colab Pro Ajuste hiperparámetros (64×3 trials) ~3 horas ~$1.58 ~$3.90 Evaluación completa (45 páginas) ~5 min ~$0.04 ~$0.11 Desarrollo y depuración (20 horas/mes) 20 horas ~$10.52 ~$26.00 Fuente: Elaboración propia. Las ventajas de la ejecución local incluyen:# Iniciar servicio OCR
+
# Iniciar servicio OCR
docker compose -f docker-compose.tuning.doctr.yml up -d doctr-gpu
# Ejecutar optimización (64 trials)
docker compose -f docker-compose.tuning.doctr.yml run raytune --service doctr --samples 64
# Detener servicios
-docker compose -f docker-compose.tuning.doctr.yml down
+docker compose -f docker-compose.tuning.doctr.yml down
+{
+{
"CER": 0.0149,
"WER": 0.0762,
"TIME": 15.8,
"PAGES": 5,
"TIME_PER_PAGE": 3.16
-}
+}
+Fase 5: Validación
Protocolo de Validación
Entorno de Ejecución
Hardware
+Software
+Justificación de Ejecución Local vs Cloud
+
+
5. Iteración rápida: Reinicio inmediato de contenedores Docker para depuración
Para un proyecto de investigación con múltiples iteraciones de ajuste de hiperparámetros, la ejecución local ahorra aproximadamente $50-100 mensuales comparado con servicios cloud, además de ofrecer mayor flexibilidad en la velocidad de iteración durante el desarrollo.
1. Tamaño del dataset: El dataset contiene 24 páginas de un único tipo de documento. Resultados pueden no generalizar a otros formatos.
-1. Ejecución en CPU: Los tiempos de procesamiento (~70s/página) serían significativamente menores con GPU.
-1. Ground truth imperfecto: El texto de referencia extraído de PDF puede contener errores en documentos con layouts complejos.
+1. Tamaño del dataset: El dataset contiene 45 páginas de documentos académicos UNIR. Resultados pueden no generalizar a otros formatos.
+1. Subconjunto de optimización: El ajuste de hiperparámetros se realizó sobre 5 páginas (páginas 5-10), lo que contribuyó al sobreajuste observado en la validación del dataset completo.
+1. Texto de referencia imperfecto: El texto de referencia extraído de PDF puede contener errores en documentos con diseños complejos.
1. Parámetro fijo: text_det_unclip_ratio quedó fijado en 0.0 durante todo el experimento por decisión de diseño inicial.
-Este capítulo ha establecido:
-1. Un objetivo general SMART: alcanzar CER < 2% mediante optimización de hiperparámetros
-2. Cinco objetivos específicos medibles y alcanzables
-3. Una metodología experimental en cinco fases claramente definidas
-4. El espacio de búsqueda de hiperparámetros y la configuración de Ray Tune
-5. Las limitaciones reconocidas del enfoque
-El siguiente capítulo presenta el desarrollo específico de la contribución, incluyendo el benchmark comparativo de soluciones OCR, la optimización de hiperparámetros y el análisis de resultados.
Síntesis del capítulo +
Los objetivos y la metodología definidos en este capítulo establecen el marco para la experimentación. El objetivo general —alcanzar un CER inferior al 2% mediante optimización de hiperparámetros— se descompone en cinco objetivos específicos que abarcan desde la comparativa inicial de soluciones hasta la validación final de la configuración optimizada.
+La metodología experimental en cinco fases garantiza un proceso sistemático y reproducible: preparación de un dataset de 45 páginas, benchmark comparativo de tres motores OCR, definición del espacio de búsqueda, ejecución de 64 trials con Ray Tune y Optuna, y validación de la configuración resultante. Las limitaciones metodológicas —tamaño del dataset, subconjunto de optimización reducido, texto de referencia automático— se reconocen explícitamente para contextualizar la interpretación de resultados.
+El capítulo siguiente pone en práctica esta metodología, presentando el desarrollo experimental completo con sus resultados y análisis.
arrollo
específico de la contribución
Este capítulo presenta el desarrollo completo del estudio comparativo y la optimización de hiperparámetros de sistemas OCR. Se estructura según el tipo de trabajo "Comparativa de soluciones" establecido por las instrucciones de UNIR: planteamiento de la comparativa, desarrollo de la comparativa, y discusión y análisis de resultados.
+color:#0098CD;mso-font-kerning:16.0pt;mso-bidi-font-weight:bold'>El presente capítulo constituye el núcleo técnico de este trabajo fin de máster. Siguiendo la estructura de "Comparativa de soluciones" establecida por las instrucciones de UNIR, se desarrollan tres fases interrelacionadas: el planteamiento y ejecución del benchmark comparativo, el proceso de optimización de hiperparámetros mediante Ray Tune, y finalmente el análisis e interpretación de los resultados obtenidos.
Esta sección presenta los resultados del estudio comparativo realizado entre tres soluciones OCR de código abierto: EasyOCR, PaddleOCR y DocTR. Los experimentos fueron documentados en el notebook ocr_benchmark_notebook.ipynb del repositorio. El objetivo es identificar el modelo base más prometedor para la posterior fase de optimización de hiperparámetros.
+Antes de abordar la optimización de hiperparámetros, era necesario seleccionar el motor OCR que serviría como base para la experimentación. Para ello, se realizó un estudio comparativo entre tres soluciones de código abierto representativas del estado del arte: EasyOCR, PaddleOCR y DocTR. Los experimentos, documentados en el notebook ocr_benchmark_notebook.ipynb del repositorio, permitieron identificar el modelo más prometedor para la fase de optimización posterior.
El reconocimiento óptico de caracteres (OCR) en documentos académicos en español presenta desafíos específicos que no han sido ampliamente abordados en la literatura:
-1. Layouts complejos: Los documentos académicos combinan texto corrido, tablas, listas numeradas, encabezados multinivel y notas al pie.
-1. Caracteres específicos del español: Acentos (á, é, í, ó, ú), eñe (ñ), diéresis (ü) y signos de puntuación invertidos (¿, ¡).
-1. Formato formal: Tipografía profesional con múltiples fuentes, tamaños y estilos (negrita, cursiva).
-1. Calidad variable: Documentos digitales de alta calidad pero con posibles artefactos de compresión PDF.
+El reconocimiento óptico de caracteres en documentos académicos en español presenta desafíos específicos que la literatura no ha abordado en profundidad. A diferencia de los benchmarks estándar en inglés, los documentos académicos hispanohablantes combinan características ortográficas propias —acentos, eñes, diéresis y signos de puntuación invertidos— con layouts estructuralmente complejos.
+Los documentos académicos típicos incluyen texto corrido entremezclado con tablas, listas numeradas, encabezados multinivel y notas al pie, lo que complica significativamente la tarea de ordenación del texto reconocido. A esto se suma el uso de tipografía profesional con múltiples fuentes, tamaños y estilos (negrita, cursiva), que puede confundir a los modelos de reconocimiento. Aunque los PDFs digitales suelen tener alta calidad, pueden contener artefactos de compresión que degradan la legibilidad de caracteres pequeños o de bajo contraste.
Se seleccionaron tres soluciones OCR de código abierto representativas del estado del arte:
Tabla 20. Soluciones OCR evaluadas en el benchmark comparativo.
-Solución | Desarrollador | Versión | Justificación de selección |
EasyOCR | Jaided AI | Última estable | Popularidad, facilidad de uso |
PaddleOCR | Baidu | PP-OCRv5 | Estado del arte industrial |
DocTR | Mindee | Última estable | Orientación académica |
Solución | Desarrollador | Versión | Justificación de selección |
EasyOCR | Jaided AI | Última estable | Popularidad, facilidad de uso |
PaddleOCR | Baidu | PP-OCRv5 | Estado del arte industrial |
DocTR | Mindee | Última estable | Orientación académica |
Fuente: Elaboración propia.
Imágenes Docker disponibles en el registro del proyecto:
-· PaddleOCR: seryus.ddns.net/unir/paddle-ocr-gpu, seryus.ddns.net/unir/paddle-ocr-cpu
-· EasyOCR: seryus.ddns.net/unir/easyocr-gpu
-· DocTR: seryus.ddns.net/unir/doctr-gpu
+· PaddleOCR: seryus.ddns.net/unir/paddle-ocr-gpu, seryus.ddns.net/unir/paddle-ocr-cpu
+· EasyOCR: seryus.ddns.net/unir/easyocr-gpu
+· DocTR: seryus.ddns.net/unir/doctr-gpu
Los criterios establecidos para evaluar las soluciones fueron:
1. Precisión (CER < 5%): Error de caracteres aceptable para documentos académicos
@@ -5119,7 +5110,7 @@ color:#0098CD;mso-font-kerning:16.0pt;mso-bidi-font-weight:bold'>Se utilizó el documento "Instrucciones para la redacción y elaboración del TFE" del Máster Universitario en Inteligencia Artificial de UNIR, ubicado en la carpeta instructions/.
Tabla 21. Características del dataset de evaluación inicial.
-Característica | Valor |
Documento fuente | Instrucciones TFE UNIR |
Número de páginas evaluadas | 5 (benchmark inicial) |
Formato | PDF digital (no escaneado) |
Idioma principal | Español |
Resolución de conversión | 300 DPI |
Formato de imagen | PNG |
Característica | Valor |
Documento fuente | Instrucciones TFE UNIR |
Número de páginas evaluadas | 5 (benchmark inicial) |
Formato | PDF digital (no escaneado) |
Idioma principal | Español |
Resolución de conversión | 300 DPI |
Formato de imagen | PNG |
Fuente: Elaboración propia.
Durante el benchmark inicial se evaluó PaddleOCR con configuración por defecto en un subconjunto del dataset. Los resultados preliminares mostraron variabilidad significativa entre páginas, con CER entre 1.54% y 6.40% dependiendo de la complejidad del layout.
Tabla 22. Variabilidad del CER por tipo de contenido.
-Tipo de contenido | CER aproximado | Observaciones |
Texto corrido | ~1.5-2% | Mejor rendimiento |
Texto con listas | ~3-4% | Rendimiento medio |
Tablas | ~5-6% | Mayor dificultad |
Encabezados + notas | ~4-5% | Layouts mixtos |
Tipo de contenido | CER aproximado | Observaciones |
Texto corrido | ~1.5-2% | Mejor rendimiento |
Texto con listas | ~3-4% | Rendimiento medio |
Tablas | ~5-6% | Mayor dificultad |
Encabezados + notas | ~4-5% | Layouts mixtos |
Fuente: Elaboración propia.
Observaciones del benchmark inicial:
@@ -5148,7 +5139,7 @@ color:#0098CD;mso-font-kerning:16.0pt;mso-bidi-font-weight:bold'>Los tres modelos evaluados representan diferentes paradigmas de OCR:
Tabla 23. Comparativa de arquitecturas OCR evaluadas.
-Modelo | Tipo | Componentes | Fortalezas Clave |
EasyOCR | End-to-end (det + rec) | CRAFT + CRNN/Transformer | Ligero, fácil de usar, multilingüe |
PaddleOCR | End-to-end (det + rec + cls) | DB + SVTR/CRNN | Soporte multilingüe robusto, pipeline configurable |
DocTR | End-to-end (det + rec) | DB/LinkNet + CRNN/SAR/ViTSTR | Orientado a investigación, API limpia |
Modelo | Tipo | Componentes | Fortalezas Clave |
EasyOCR | End-to-end (det + rec) | CRAFT + CRNN/Transformer | Ligero, fácil de usar, multilingüe |
PaddleOCR | End-to-end (det + rec + cls) | DB + SVTR/CRNN | Soporte multilingüe robusto, pipeline configurable |
DocTR | End-to-end (det + rec) | DB/LinkNet + CRNN/SAR/ViTSTR | Orientado a investigación, API limpia |
Fuente: Elaboración propia.
· documento → doccumento (consonante duplicada)
Ejemplo de predicción de PaddleOCR para una página:
-"Escribe siempre al menos un párrafo de introducción en cada capítulo o apartado, explicando de qué vas a tratar en esa sección. Evita que aparezcan dos encabezados de nivel consecutivos sin ningún texto entre medias. [...] En esta titulacióon se cita de acuerdo con la normativa Apa."
+"Escribe siempre al menos un párrafo de introducción en cada capítulo o apartado, explicando de qué vas a tratar en esa sección. Evita que aparezcan dos encabezados de nivel consecutivos sin ningún texto entre medias. [...] En esta titulacióon se cita de acuerdo con la normativa Apa."
Errores identificados en este ejemplo:
· titulacióon en lugar de titulación (carácter duplicado)
· Apa en lugar de APA (capitalización)
@@ -5172,7 +5163,7 @@ color:#0098CD;mso-font-kerning:16.0pt;mso-bidi-font-weight:bold'>La selección de PaddleOCR para la fase de optimización se basó en los siguientes criterios:
Tabla 24. Evaluación de criterios de selección.
-Criterio | EasyOCR | PaddleOCR | DocTR |
CER benchmark | ~6-8% | ~5-6% | ~7-9% |
Configurabilidad | Baja (3 params) | Alta (>10 params) | Media (5 params) |
Soporte español | Sí | Sí (dedicado) | Limitado |
Documentación | Media | Alta | Alta |
Mantenimiento | Medio | Alto | Medio |
Criterio | EasyOCR | PaddleOCR | DocTR |
CER benchmark | ~6-8% | ~5-6% | ~7-9% |
Configurabilidad | Baja (3 params) | Alta (>10 params) | Media (5 params) |
Soporte español | Sí | Sí (dedicado) | Limitado |
Documentación | Media | Alta | Alta |
Mantenimiento | Medio | Alto | Medio |
Fuente: Elaboración propia.
1. Ground truth automático: El texto de referencia se extrajo programáticamente del PDF, lo cual puede introducir errores en layouts complejos donde el orden de lectura no es evidente.
1. Ejecución en CPU: Todos los experimentos se realizaron en CPU, limitando la exploración de configuraciones que podrían beneficiarse de aceleración GPU.
-Esta sección ha presentado:
-1. La identificación del problema y los criterios de éxito establecidos
-2. La configuración detallada del benchmark con tres soluciones OCR
-3. Los resultados cuantitativos y cualitativos obtenidos
-4. La justificación de la selección de PaddleOCR para optimización
-5. Las limitaciones reconocidas del benchmark
-Fuentes de datos utilizadas:
-· ocr_benchmark_notebook.ipynb: Código del benchmark
-· Documentación oficial de PaddleOCR
+El benchmark comparativo ha permitido identificar PaddleOCR como la solución más prometedora para la fase de optimización, gracias a su combinación de rendimiento base aceptable (~5-6% CER), alta configurabilidad del pipeline y documentación técnica completa. Sin embargo, el análisis también reveló limitaciones importantes: el tamaño reducido del benchmark (5 páginas), la restricción a un único tipo de documento, y la extracción automática del ground truth que puede introducir errores en layouts complejos. Estas limitaciones se tendrán en cuenta al interpretar los resultados de la fase de optimización.
+Fuentes de datos: ocr_benchmark_notebook.ipynb y documentación oficial de PaddleOCR.
Esta sección describe el proceso de optimización de hiperparámetros de PaddleOCR utilizando Ray Tune con el algoritmo de búsqueda Optuna. Los experimentos fueron implementados en src/run_tuning.py con la librería de utilidades src/raytune_ocr.py, y los resultados se almacenaron en src/results/.
-La optimización de hiperparámetros representa una alternativa al fine-tuning tradicional que no requiere:
-· Acceso a GPU dedicada
-· Dataset de entrenamiento etiquetado
-· Modificación de los pesos del modelo
+Una vez seleccionado PaddleOCR como motor base, el siguiente paso fue explorar sistemáticamente su espacio de configuración para identificar los hiperparámetros que maximizan el rendimiento en documentos académicos en español. Para ello se empleó Ray Tune con el algoritmo de búsqueda Optuna, una combinación que permite explorar eficientemente espacios de búsqueda mixtos (parámetros continuos y categóricos). Los experimentos se implementaron en src/run_tuning.py con apoyo de la librería src/raytune_ocr.py, almacenándose los resultados en src/results/.
+Esta aproximación ofrece ventajas significativas frente al fine-tuning tradicional: no requiere datasets de entrenamiento etiquetados, no modifica los pesos del modelo preentrenado, y puede ejecutarse con hardware de consumo cuando se dispone de aceleración GPU.
El experimento se ejecutó en el siguiente entorno:
Tabla 25. Entorno de ejecución del experimento.
-Componente | Versión/Especificación |
Sistema operativo | Ubuntu 24.04.3 LTS |
Python | 3.12.3 |
PaddlePaddle | 3.2.2 |
PaddleOCR | 3.3.2 |
Ray | 2.52.1 |
Optuna | 4.7.0 |
CPU | AMD Ryzen 7 5800H |
RAM | 16 GB DDR4 |
GPU | NVIDIA RTX 3060 Laptop (5.66 GB VRAM) |
Componente | Versión/Especificación |
Sistema operativo | Ubuntu 24.04.3 LTS |
Python | 3.12.3 |
PaddlePaddle | 3.2.2 |
PaddleOCR | 3.3.2 |
Ray | 2.52.1 |
Optuna | 4.7.0 |
CPU | AMD Ryzen 7 5800H |
RAM | 16 GB DDR4 |
GPU | NVIDIA RTX 3060 Laptop (5.66 GB VRAM) |
Fuente: Elaboración propia.
Esta arquitectura containerizada permite ejecutar cada componente en su entorno aislado óptimo, comunicándose via API REST:
Figura 5. Arquitectura de ejecución con Docker Compose
-

Fuente: Elaboración propia.
La arquitectura containerizada (src/docker-compose.tuning.*.yml) ofrece:
@@ -5239,33 +5220,117 @@ color:#0098CD;mso-font-kerning:16.0pt;mso-bidi-font-weight:bold'>3. Comunicación via API REST (endpoints /health y /evaluate)
4. Soporte para GPU mediante nvidia-docker
-Respuesta del servicio OCR: La infraestructura del proyecto se basa en contenedores Docker para garantizar reproducibilidad y aislamiento de dependencias. Se generaron seis imágenes Docker, cada una optimizada para su propósito específico. Tabla 26. Imágenes Docker generadas para el proyecto. Imagen Propósito Base Puerto PaddleOCR con aceleración GPU nvidia/cuda:12.4.1-cudnn-runtime 8002 PaddleOCR para entornos sin GPU python:3.11-slim 8002 EasyOCR con aceleración GPU nvidia/cuda:13.0.2-cudnn-runtime 8002* DocTR con aceleración GPU nvidia/cuda:13.0.2-cudnn-runtime 8003 Orquestador Ray Tune python:3.12-slim - Fuente: Elaboración propia. Figura 6. Arquitectura de microservicios para optimización OCR Fuente: Elaboración propia. Los Dockerfiles utilizan una estrategia de build multi-stage para optimizar tiempos de construcción y tamaño de imágenes: Figura 7. Estrategia de build multi-stage Fuente: Elaboración propia. Ventajas de esta estrategia: 1. Caché de dependencias: La etapa base (CUDA + dependencias) se cachea y reutiliza 2. Builds rápidos: Los cambios de código solo reconstruyen la etapa de deploy (~10 segundos) 3. Imágenes optimizadas: Solo se incluyen los archivos necesarios para ejecución El proyecto incluye múltiples archivos Docker Compose para diferentes escenarios de uso: Tabla 27. Archivos Docker Compose del proyecto. Archivo Propósito Servicios Optimización principal RayTune + PaddleOCR + DocTR Optimización EasyOCR RayTune + EasyOCR Optimización PaddleOCR RayTune + PaddleOCR Optimización DocTR RayTune + DocTR Fuente: Elaboración propia. Nota: EasyOCR y PaddleOCR utilizan el mismo puerto (8002). Debido a limitaciones de recursos GPU (VRAM insuficiente para ejecutar múltiples modelos OCR simultáneamente), solo se ejecuta un servicio a la vez durante los experimentos. Por esta razón, EasyOCR tiene su propio archivo Docker Compose separado. Se utilizan volúmenes Docker nombrados para persistir los modelos descargados entre ejecuciones: Tabla 28. Volúmenes Docker para caché de modelos. Volumen Servicio Contenido paddlex-model-cache PaddleOCR Modelos PP-OCRv5 (~500 MB) easyocr-model-cache EasyOCR Modelos CRAFT + CRNN (~400 MB) doctr-model-cache DocTR Modelos db_resnet50 + crnn_vgg16_bn (~300 MB) Fuente: Elaboración propia. Todos los servicios implementan health checks para garantizar disponibilidad antes de iniciar la optimización: Los tiempos de start_period varían según el servicio debido al tiempo de carga de modelos: · PaddleOCR: 60 segundos (modelos más ligeros) · EasyOCR: 120 segundos (carga de modelos CRAFT) · DocTR: 180 segundos (modelos ResNet más pesados) Figura 8. Flujo de ejecución de optimización con Ray Tune Fuente: Elaboración propia. Para reproducir los experimentos: Los resultados de los experimentos están disponibles en: · src/results/raytune_paddle_results_20260119_122609.csv · src/results/raytune_easyocr_results_20260119_120204.csv · src/results/raytune_doctr_results_20260119_121445.csv Para la fase de optimización se extendió el dataset: Tabla 26. Características del dataset de optimización. Característica Valor Páginas totales 24 Páginas por trial 5 (páginas 5-10) Estructura Carpetas img/ y txt/ pareadas Resolución 300 DPI Formato imagen PNG Tabla 29. Características del dataset de optimización. Característica Valor Páginas totales 24 Páginas por trial 5 (páginas 5-10) Estructura Carpetas img/ y txt/ pareadas Resolución 300 DPI Formato imagen PNG Fuente: Elaboración propia. La clase ImageTextDataset gestiona la carga de pares imagen-texto desde la estructura de carpetas pareadas. La implementación está disponible en el repositorio (ver Anexo A). El espacio de búsqueda se definió considerando los hiperparámetros más relevantes identificados en la documentación de PaddleOCR, utilizando tune.choice() para parámetros booleanos y tune.uniform() para umbrales continuos. La implementación está disponible en src/raytune/raytune_ocr.py (ver Anexo A). Tabla 27. Descripción detallada del espacio de búsqueda. Parámetro Tipo Rango Descripción use_doc_orientation_classify Booleano {True, False} Clasificación de orientación del documento completo use_doc_unwarping Booleano {True, False} Corrección de deformación/curvatura textline_orientation Booleano {True, False} Clasificación de orientación por línea de texto text_det_thresh Continuo [0.0, 0.7] Umbral de probabilidad para píxeles de texto text_det_box_thresh Continuo [0.0, 0.7] Umbral de confianza para cajas detectadas text_det_unclip_ratio Fijo 0.0 Coeficiente de expansión (no explorado) text_rec_score_thresh Continuo [0.0, 0.7] Umbral de confianza de reconocimiento Tabla 30. Descripción detallada del espacio de búsqueda. Parámetro Tipo Rango Descripción use_doc_orientation_classify Booleano {True, False} Clasificación de orientación del documento completo use_doc_unwarping Booleano {True, False} Corrección de deformación/curvatura textline_orientation Booleano {True, False} Clasificación de orientación por línea de texto text_det_thresh Continuo [0.0, 0.7] Umbral de probabilidad para píxeles de texto text_det_box_thresh Continuo [0.0, 0.7] Umbral de confianza para cajas detectadas text_det_unclip_ratio Fijo 0.0 Coeficiente de expansión (no explorado) text_rec_score_thresh Continuo [0.0, 0.7] Umbral de confianza de reconocimiento Fuente: Elaboración propia. Justificación del espacio:# Iniciar servicio OCR con GPU
+
# Iniciar servicio OCR con GPU
docker compose -f docker-compose.tuning.doctr.yml up -d doctr-gpu
# Ejecutar optimización (64 trials)
docker compose -f docker-compose.tuning.doctr.yml run raytune --service doctr --samples 64
# Detener servicios
-docker compose -f docker-compose.tuning.doctr.yml down
+docker compose -f docker-compose.tuning.doctr.yml down
+{
+{
"CER": 0.0149,
"WER": 0.0762,
"TIME": 15.8,
"PAGES": 5,
"TIME_PER_PAGE": 3.16
-}
+}
+Infraestructura Docker
+Arquitectura de Microservicios
+
Estrategia de Build Multi-Stage
+
Docker Compose Files
+Gestión de Volúmenes
+Health Checks y Monitorización
+healthcheck:
+ test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')"]
+ interval: 30s
+ timeout: 10s
+ retries: 3
+ start_period: 60s # PaddleOCR: 60s, EasyOCR: 120s, DocTR: 180s
+Flujo de Ejecución Completo
+
Reproducibilidad
+# 1. Clonar repositorio
+git clone https://seryus.ddns.net/unir/MastersThesis.git
+cd MastersThesis/src
+
+# 2. Iniciar servicio OCR (requiere nvidia-docker)
+docker compose -f docker-compose.tuning.paddle.yml up -d paddle-ocr-gpu
+
+# 3. Verificar health check
+curl http://localhost:8002/health
+
+# 4. Ejecutar optimización (64 trials)
+docker compose -f docker-compose.tuning.paddle.yml run raytune \
+ --service paddle --samples 64
+
+# 5. Resultados en src/results/
+ls -la results/raytune_paddle_results_*.csv
+
+# 6. Limpiar
+docker compose -f docker-compose.tuning.paddle.yml down
+Dataset Extendido
+Espacio de Búsqueda
+
1. Parámetros booleanos completos: Los tres parámetros de preprocesamiento se exploran completamente para identificar cuáles son necesarios para documentos digitales.
Se configuró Ray Tune con OptunaSearch como algoritmo de búsqueda, optimizando CER en 64 trials con 2 ejecuciones concurrentes. La implementación está disponible en src/raytune/raytune_ocr.py (ver Anexo A).
-Tabla 28. Parámetros de configuración de Ray Tune.
-Parámetro | Valor | Justificación |
Métrica objetivo | CER | Métrica estándar para OCR |
Modo | min | Minimizar tasa de error |
Algoritmo | OptunaSearch (TPE) | Eficiente para espacios mixtos |
Número de trials | 64 | Balance entre exploración y tiempo |
Trials concurrentes | 2 | Limitado por memoria disponible |
Tabla 31. Parámetros de configuración de Ray Tune.
+Parámetro | Valor | Justificación |
Métrica objetivo | CER | Métrica estándar para OCR |
Modo | min | Minimizar tasa de error |
Algoritmo | OptunaSearch (TPE) | Eficiente para espacios mixtos |
Número de trials | 64 | Balance entre exploración y tiempo |
Trials concurrentes | 2 | Limitado por memoria disponible |
Fuente: Elaboración propia.
Elección de 64 trials:
@@ -5287,74 +5352,85 @@ docker compose -f docker-compose.tuning.doctr.yml downEl experimento se ejecutó exitosamente con los siguientes resultados globales:
-Tabla 29. Resumen de la ejecución del experimento.
-Métrica | Valor |
Trials completados | 64/64 |
Trials fallidos | 0 |
Tiempo total | ~6.4 horas |
Tiempo medio por trial | 367.72 segundos |
Páginas procesadas | 320 (64 trials × 5 páginas) |
Tabla 32. Resumen de la ejecución del experimento.
+Métrica | Valor |
Trials completados | 64/64 |
Trials fallidos | 0 |
Tiempo total | ~6.4 horas |
Tiempo medio por trial | 367.72 segundos |
Páginas procesadas | 320 (64 trials × 5 páginas) |
Fuente: Elaboración propia.
Del archivo CSV de resultados (raytune_paddle_subproc_results_20251207_192320.csv):
-Tabla 30. Estadísticas descriptivas de los 64 trials.
-Estadística | CER | WER | Tiempo (s) | Tiempo/Página (s) |
count | 64 | 64 | 64 | 64 |
mean | 5.25% | 14.28% | 347.61 | 69.42 |
std | 11.03% | 10.75% | 7.88 | 1.57 |
min | 1.15% | 9.89% | 320.97 | 64.10 |
25% | 1.20% | 10.04% | 344.24 | 68.76 |
50% (mediana) | 1.23% | 10.20% | 346.42 | 69.19 |
75% | 4.03% | 13.20% | 350.14 | 69.93 |
max | 51.61% | 59.45% | 368.57 | 73.63 |
Del archivo CSV de resultados (src/results/raytune_paddle_results_20260119_122609.csv):
+Tabla 33. Estadísticas descriptivas de los 64 trials.
+Estadística | CER | WER | Tiempo/Página (s) |
count | 64 | 64 | 64 |
mean | 2.30% | 9.25% | 0.84 |
std | 2.20% | 1.78% | 0.53 |
min | 0.79% | 6.80% | 0.56 |
50% (mediana) | 0.87% | 8.39% | 0.59 |
max | 7.30% | 13.20% | 2.22 |
Fuente: Elaboración propia.
Observaciones:
-1. Alta varianza en CER: La desviación estándar (11.03%) es mayor que la media (5.25%), indicando una distribución muy dispersa con algunos valores extremos.
-1. Mediana vs Media: La mediana del CER (1.23%) es mucho menor que la media (5.25%), confirmando una distribución sesgada hacia valores bajos con outliers altos.
-1. Tiempo consistente: El tiempo de ejecución es muy estable (std = 1.57 s/página), indicando que las configuraciones de hiperparámetros no afectan significativamente el tiempo de inferencia.
+1. Baja varianza en CER: La desviación estándar (2.20%) es similar a la media (2.30%), indicando una distribución relativamente consistente sin valores extremos catastróficos.
+1. Mediana vs Media: La mediana del CER (0.87%) es menor que la media (2.30%), confirmando una distribución ligeramente sesgada hacia valores bajos.
+1. Velocidad GPU: El tiempo de ejecución promedio es de 0.84 s/página, lo que representa una aceleración significativa respecto a la ejecución en CPU (~69 s/página, 82x más rápido).
Tabla 31. Distribución de trials por rango de CER.
-Rango CER | Número de trials | Porcentaje |
< 2% | 43 | 67.2% |
2% - 5% | 7 | 10.9% |
5% - 10% | 2 | 3.1% |
10% - 20% | 5 | 7.8% |
> 20% | 7 | 10.9% |
Tabla 34. Distribución de trials por rango de CER.
+Rango CER | Número de trials | Porcentaje |
< 2% | 43 | 67.2% |
2% - 5% | 10 | 15.6% |
5% - 10% | 11 | 17.2% |
> 10% | 0 | 0.0% |
Fuente: Elaboración propia.
La mayoría de trials (67.2%) alcanzaron CER < 2%, cumpliendo el objetivo establecido. Sin embargo, un 10.9% de trials presentaron fallos catastróficos (CER > 20%).
+Figura 9. Distribución de trials por rango de CER
+
Fuente: Elaboración propia.
+La mayoría de trials (67.2%) alcanzaron CER < 2%, cumpliendo el objetivo establecido. Ningún trial presentó fallos catastróficos (CER > 10%), demostrando la estabilidad de la optimización con GPU.
La configuración que minimizó el CER fue:
-Tabla 32. Configuración óptima identificada. Parámetro Valor óptimo Valor por defecto Cambio textline_orientation True False Activado use_doc_orientation_classify False False Sin cambio use_doc_unwarping False False Sin cambio text_det_thresh 0.4690 0.3 +0.169 text_det_box_thresh 0.5412 0.6 -0.059 text_det_unclip_ratio 0.0 1.5 -1.5 (fijado) text_rec_score_thresh 0.6350 0.5 +0.135 Tabla 35. Configuración óptima identificada. Parámetro Valor óptimo Valor por defecto Cambio textline_orientation True False Activado use_doc_orientation_classify True False Activado use_doc_unwarping False False Sin cambio text_det_thresh 0.0462 0.3 -0.254 text_det_box_thresh 0.4862 0.6 -0.114 text_det_unclip_ratio 0.0 1.5 -1.5 (fijado) text_rec_score_thresh 0.5658 0.5 +0.066 Fuente: Elaboración propia. Se calculó la correlación de Pearson entre los parámetros continuos y las métricas de error: Tabla 33. Correlación de parámetros con CER. Parámetro Correlación con CER Interpretación text_det_thresh -0.523 Correlación moderada negativa text_det_box_thresh +0.226 Correlación débil positiva text_rec_score_thresh -0.161 Correlación débil negativa text_det_unclip_ratio NaN Varianza cero (valor fijo) Tabla 36. Correlación de parámetros con CER. Parámetro Correlación con CER Interpretación text_det_thresh -0.523 Correlación moderada negativa text_det_box_thresh +0.226 Correlación débil positiva text_rec_score_thresh -0.161 Correlación débil negativa text_det_unclip_ratio NaN Varianza cero (valor fijo) Fuente: Elaboración propia. Tabla 34. Correlación de parámetros con WER. Parámetro Correlación con WER Interpretación text_det_thresh -0.521 Correlación moderada negativa text_det_box_thresh +0.227 Correlación débil positiva text_rec_score_thresh -0.173 Correlación débil negativa Tabla 37. Correlación de parámetros con WER. Parámetro Correlación con WER Interpretación text_det_thresh -0.521 Correlación moderada negativa text_det_box_thresh +0.227 Correlación débil positiva text_rec_score_thresh -0.173 Correlación débil negativa Fuente: Elaboración propia. Figura 10. Correlación de hiperparámetros con CER Fuente: Elaboración propia. Leyenda: Valores negativos indican que aumentar el parámetro reduce el CER. El parámetro text_det_thresh tiene la correlación más fuerte (-0.52). Hallazgo clave: El parámetro text_det_thresh muestra la correlación más fuerte (-0.52 con ambas métricas), indicando que valores más altos de este umbral tienden a reducir el error. Este umbral controla qué píxeles se consideran "texto" en el mapa de probabilidad del detector. El parámetro booleano textline_orientation demostró tener el mayor impacto en el rendimiento: Tabla 35. Impacto del parámetro textline_orientation. textline_orientation CER Medio CER Std WER Medio N trials True 3.76% 7.12% 12.73% 32 False 12.40% 14.93% 21.71% 32 Tabla 38. Impacto del parámetro textline_orientation. textline_orientation CER Medio CER Std WER Medio N trials True 3.76% 7.12% 12.73% 32 False 12.40% 14.93% 21.71% 32 Fuente: Elaboración propia. Interpretación: 1. Reducción del CER: Con textline_orientation=True, el CER medio es 3.3 veces menor (3.76% vs 12.40%). 1. Menor varianza: La desviación estándar también se reduce significativamente (7.12% vs 14.93%), indicando resultados más consistentes. 1. Reducción del CER: 69.7% cuando se habilita la clasificación de orientación de línea. Figura 6. Impacto de textline_orientation en CER Figura 11. Impacto de textline_orientation en CER Fuente: Elaboración propia. Explicación técnica: El parámetro textline_orientation activa un clasificador que determina la orientación de cada línea de texto detectada. Para documentos con layouts mixtos (tablas, encabezados laterales, direcciones postales), este clasificador asegura que el texto se lea en el orden correcto, evitando la mezcla de líneas de diferentes columnas o secciones. Los trials con CER muy alto (>20%) presentaron patrones específicos: Tabla 36. Características de trials con fallos catastróficos. Trial CER text_det_thresh textline_orientation Diagnóstico #47 51.61% 0.017 True Umbral muy bajo #23 43.29% 0.042 False Umbral bajo + sin orientación #12 38.76% 0.089 False Umbral bajo + sin orientación #56 35.12% 0.023 False Umbral muy bajo + sin orientación Tabla 39. Características de trials con fallos catastróficos. Trial CER text_det_thresh textline_orientation Diagnóstico #47 51.61% 0.017 True Umbral muy bajo #23 43.29% 0.042 False Umbral bajo + sin orientación #12 38.76% 0.089 False Umbral bajo + sin orientación #56 35.12% 0.023 False Umbral muy bajo + sin orientación Fuente: Elaboración propia. Diagnóstico: Recomendación: Evitar text_det_thresh < 0.1 en cualquier configuración. La configuración óptima identificada se evaluó sobre el dataset completo de 24 páginas, comparando con la configuración baseline (valores por defecto de PaddleOCR). Los parámetros optimizados más relevantes fueron: textline_orientation=True, text_det_thresh=0.4690, text_det_box_thresh=0.5412, y text_rec_score_thresh=0.6350. Tabla 37. Comparación baseline vs optimizado (24 páginas). Modelo CER Precisión Caracteres WER Precisión Palabras PaddleOCR (Baseline) 7.78% 92.22% 14.94% 85.06% PaddleOCR-HyperAdjust 1.49% 98.51% 7.62% 92.38% La configuración óptima identificada se evaluó sobre el dataset completo de 45 páginas, comparando con la configuración baseline (valores por defecto de PaddleOCR). Los parámetros optimizados más relevantes fueron: textline_orientation=True, use_doc_orientation_classify=True, text_det_thresh=0.0462, text_det_box_thresh=0.4862, y text_rec_score_thresh=0.5658. Tabla 40. Comparación baseline vs optimizado (45 páginas). Modelo CER Precisión Caracteres WER Precisión Palabras PaddleOCR (Baseline) 8.85% 91.15% 13.05% 86.95% PaddleOCR-HyperAdjust 7.72% 92.28% 11.40% 88.60% Fuente: Elaboración propia. Nota sobre generalización: El mejor trial individual (5 páginas) alcanzó un CER de 0.79%, cumpliendo el objetivo de CER < 2%. Sin embargo, al aplicar la configuración al dataset completo de 45 páginas, el CER aumentó a 7.72%, evidenciando sobreajuste al subconjunto de entrenamiento. Esta diferencia es un hallazgo importante que se discute en la sección de análisis. Tabla 38. Análisis cuantitativo de la mejora. Forma de Medición CER WER Valor baseline 7.78% 14.94% Valor optimizado 1.49% 7.62% Mejora absoluta -6.29 pp -7.32 pp Reducción relativa del error 80.9% 49.0% Factor de mejora 5.2× 2.0× Tabla 41. Análisis cuantitativo de la mejora. Forma de Medición CER WER Valor baseline 8.85% 13.05% Valor optimizado 7.72% 11.40% Mejora absoluta -1.13 pp -1.65 pp Reducción relativa del error 12.8% 12.6% Factor de mejora 1.15× 1.14× Mejor trial (5 páginas) 0.79% 7.78% Fuente: Elaboración propia. Figura 7. Reducción de errores: Baseline vs Optimizado Figura 12. Reducción de errores: Baseline vs Optimizado (45 páginas) Fuente: Elaboración propia. Leyenda: CER = Character Error Rate, WER = Word Error Rate. Baseline = configuración por defecto de PaddleOCR. Optimizado = configuración encontrada por Ray Tune. Leyenda: CER = Character Error Rate, WER = Word Error Rate. Baseline = configuración por defecto de PaddleOCR. Optimizado = configuración encontrada por Ray Tune. Los valores corresponden al dataset completo de 45 páginas. En un documento típico de 10,000 caracteres: Tabla 39. En un documento típico de 10,000 caracteres Configuración Caracteres con error Palabras con error* Baseline ~778 ~225 Optimizada ~149 ~115 Reducción 629 menos 110 menos Tabla 42. En un documento típico de 10,000 caracteres Configuración Caracteres con error Palabras con error* Baseline ~885 ~196 Optimizada (full dataset) ~772 ~171 Optimizada (mejor trial) ~79 ~117 Reducción (full dataset) 113 menos 25 menos Fuente: Elaboración propia. *Asumiendo longitud media de palabra = 6.6 caracteres en español. Interpretación del notebook: "La optimización de hiperparámetros mejoró la precisión de caracteres de 92.2% a 98.5%, una ganancia de 6.3 puntos porcentuales. Aunque el baseline ya ofrecía resultados aceptables, la configuración optimizada reduce los errores residuales en un 80.9%." Interpretación: "La optimización de hiperparámetros logró una mejora del 12.8% en el CER sobre el dataset completo de 45 páginas. Aunque esta mejora es más modesta que la observada en los trials individuales (donde se alcanzó 0.79% CER), demuestra el valor de la optimización sistemática. La diferencia entre el mejor trial (0.79%) y el resultado en dataset completo (7.72%) revela un fenómeno de sobreajuste al subconjunto de 5 páginas usado para evaluación." Tabla 40. Métricas de tiempo del experimento. Métrica Valor Tiempo total del experimento ~6.4 horas Tiempo medio por trial 347.61 segundos (~5.8 min) Tiempo medio por página 69.42 segundos Variabilidad (std) 1.57 segundos/página Páginas procesadas totales 320 Tabla 43. Métricas de tiempo del experimento (GPU). Métrica Valor Tiempo total del experimento ~1.5 horas Tiempo medio por trial ~4.2 segundos Tiempo medio por página 0.84 segundos Variabilidad (std) 0.53 segundos/página Páginas procesadas totales 320 Fuente: Elaboración propia. Observaciones: 1. El tiempo por página (~70 segundos) corresponde a ejecución en CPU sin aceleración. 2. La variabilidad del tiempo es muy baja, indicando que los hiperparámetros no afectan significativamente la velocidad. 3. Con GPU, los tiempos serían 10-50× menores según benchmarks de PaddleOCR. Esta sección ha presentado: 1. Configuración del experimento: Arquitectura Docker Compose, dataset extendido, espacio de búsqueda de 7 dimensiones 1. Resultados estadísticos: - CER medio: 5.25% (std: 11.03%) - CER mínimo: 1.15% - 67.2% de trials con CER < 2% 1. Hallazgos clave: - textline_orientation=True reduce CER en 69.7% - text_det_thresh tiene correlación -0.52 con CER - Valores de text_det_thresh < 0.1 causan fallos catastróficos 1. Mejora final: CER reducido de 7.78% a 1.49% (reducción del 80.9%) Fuentes de datos: · src/run_tuning.py: Script principal de optimización · src/raytune_ocr.py: Librería de utilidades Ray Tune · src/results/: Resultados CSV de los trials 1. El tiempo por página (~0.84 segundos) corresponde a ejecución con GPU (RTX 3060). 2. La variabilidad del tiempo es moderada (std = 0.53 s/página), con algunos trials más lentos debido a configuraciones con módulos de preprocesamiento activos. 3. En comparación, la ejecución en CPU requiere ~69 segundos/página (82× más lento), lo que justifica el uso de GPU para optimización y producción. Los 64 trials ejecutados con Ray Tune y aceleración GPU revelaron patrones claros en el comportamiento de PaddleOCR. El hallazgo más significativo es que los parámetros estructurales —textline_orientation y use_doc_orientation_classify— tienen mayor impacto que los umbrales numéricos: activarlos reduce el CER medio de 12.40% a 3.76%. En cuanto a umbrales, valores bajos de text_det_thresh (~0.05) benefician el rendimiento, mientras que use_doc_unwarping resulta innecesario para PDFs digitales. El mejor trial alcanzó un CER de 0.79%, cumpliendo el objetivo de CER < 2%. No obstante, la validación sobre el dataset completo de 45 páginas arrojó un CER de 7.72%, evidenciando sobreajuste al subconjunto de optimización de 5 páginas. Aun así, esto representa una mejora del 12.8% respecto al baseline (8.85%), demostrando el valor de la optimización sistemática incluso cuando la generalización es imperfecta. Fuentes de datos: src/run_tuning.py, src/raytune_ocr.py, src/results/raytune_paddle_results_20260119_122609.csv. Esta sección presenta un análisis consolidado de los resultados obtenidos en las fases de benchmark comparativo y optimización de hiperparámetros. Se discuten las implicaciones prácticas, se evalúa el cumplimiento de los objetivos planteados y se identifican las limitaciones del estudio. Los resultados obtenidos en las secciones anteriores requieren un análisis que trascienda los números individuales para comprender su significado práctico. En esta sección se consolidan los hallazgos del benchmark comparativo y la optimización de hiperparámetros, evaluando hasta qué punto se han cumplido los objetivos planteados y qué limitaciones condicionan la generalización de las conclusiones. Tabla 41. Evolución del rendimiento a través del estudio. Fase Configuración CER Mejora vs anterior Benchmark inicial Baseline (5 páginas) ~5-6% - Optimización (mejor trial) Optimizada (5 páginas) 1.15% ~80% Validación final Optimizada (24 páginas) 1.49% - Tabla 44. Evolución del rendimiento a través del estudio. Fase Configuración CER Mejora vs anterior Benchmark inicial Baseline (5 páginas) ~7-8% - Optimización (mejor trial) Optimizada (5 páginas) 0.79% ~90% vs baseline Validación final Optimizada (45 páginas) 7.72% 12.8% vs baseline Fuente: Elaboración propia. El incremento del CER de 1.15% (5 páginas) a 1.49% (24 páginas) es esperado debido a la mayor diversidad de layouts en el dataset completo. Figura 13. Evolución del CER a través del estudio Fuente: Elaboración propia. Leyenda: El mejor trial alcanza CER 0.79% (objetivo cumplido). La validación sobre dataset completo muestra CER 7.72%, evidenciando sobreajuste al subconjunto de optimización. El incremento del CER de 0.79% (5 páginas) a 7.72% (45 páginas) evidencia sobreajuste al subconjunto de optimización. Este fenómeno es esperado cuando se optimiza sobre un subconjunto pequeño y se valida sobre el dataset completo con mayor diversidad de layouts. Tabla 42. Verificación del objetivo general. Aspecto Objetivo Resultado Cumplimiento Métrica CER CER ✓ Umbral < 2% 1.49% ✓ Método Sin fine-tuning Solo hiperparámetros ✓ Hardware Sin GPU CPU only ✓ Tabla 45. Verificación del objetivo general. Aspecto Objetivo Resultado (trial) Resultado (full) Cumplimiento Métrica CER CER CER ✓ Umbral < 2% 0.79% 7.72% Parcial Método Sin fine-tuning Solo hiperparámetros Solo hiperparámetros ✓ Hardware GPU RTX 3060 RTX 3060 ✓ Fuente: Elaboración propia. Análisis del cumplimiento: El objetivo de CER < 2% se cumple en el mejor trial individual (0.79%), demostrando que la optimización de hiperparámetros puede alcanzar la precisión objetivo. Sin embargo, la validación sobre el dataset completo (7.72%) muestra que la generalización requiere trabajo adicional, como un subconjunto de optimización más representativo o técnicas de regularización. Basándose en el análisis de correlación y el impacto observado: Tabla 43. Ranking de importancia de hiperparámetros. Rank Parámetro Impacto Evidencia 1 textline_orientation Crítico Reduce CER 69.7% 2 text_det_thresh Alto Correlación -0.52 3 text_rec_score_thresh Medio Correlación -0.16 4 text_det_box_thresh Bajo Correlación +0.23 5 use_doc_orientation_classify Nulo Sin mejora 6 use_doc_unwarping Nulo Sin mejora Basándose en el análisis de los resultados de optimización: Tabla 46. Ranking de importancia de hiperparámetros. Rank Parámetro Impacto Evidencia 1 textline_orientation Crítico Presente en todos los mejores trials 2 use_doc_orientation_classify Alto Activado en configuración óptima 3 text_det_thresh Alto Valor óptimo bajo (0.0462) 4 text_det_box_thresh Medio Moderado (0.4862) 5 text_rec_score_thresh Medio Moderado (0.5658) 6 use_doc_unwarping Nulo Desactivado en configuración óptima Fuente: Elaboración propia. Figura 14. Ranking de importancia de hiperparámetros Fuente: Elaboración propia. Leyenda: Impacto relativo estimado basado en análisis de correlación y presencia en configuraciones óptimas. textline_orientation es el parámetro más crítico. Por qué es tan importante: El clasificador de orientación de línea resuelve un problema fundamental en documentos con layouts complejos: determinar el orden correcto de lectura. Sin este clasificador: Recomendación: Siempre activar textline_orientation=True para documentos estructurados. Comportamiento observado: Tabla 44. Comportamiento observado Rango CER típico Comportamiento 0.0 - 0.1 >20% Fallos catastróficos 0.1 - 0.3 5-15% Rendimiento pobre 0.3 - 0.5 1-5% Rendimiento óptimo 0.5 - 0.7 2-8% Rendimiento aceptable Tabla 47. Comportamiento observado Rango CER típico Comportamiento 0.0 - 0.1 1-3% Detecta más texto, incluyendo bordes 0.1 - 0.3 2-5% Rendimiento variable 0.3 - 0.5 3-7% Balance precisión/recall 0.5 - 0.7 4-7% Más conservador Fuente: Elaboración propia. Interpretación: · Valores muy bajos (< 0.1) incluyen ruido y artefactos como "texto" · Valores muy altos (> 0.6) filtran texto legítimo de bajo contraste · El rango óptimo (0.3-0.5) balancea precisión y recall de detección Valor óptimo encontrado: 0.4690 use_doc_orientation_classify y use_doc_unwarping: Estos módulos están diseñados para: · En ejecución GPU con modelos Mobile, valores bajos de text_det_thresh funcionan bien · El valor óptimo (0.0462) indica que una detección más sensible beneficia el rendimiento · A diferencia de CPU, no se observaron fallos catastróficos con valores bajos Valor óptimo encontrado: 0.0462 use_doc_orientation_classify: En la configuración óptima GPU, este parámetro está activado (True), a diferencia de lo observado en experimentos anteriores. Esto sugiere que la clasificación de orientación del documento puede beneficiar incluso documentos digitales cuando se combina con textline_orientation=True. use_doc_unwarping: Este módulo permanece desactivado en la configuración óptima. Está diseñado para: · Documentos escaneados con rotación · Fotografías de documentos con perspectiva · Documentos curvados o deformados Para documentos PDF digitales como los evaluados, estos módulos son innecesarios e incluso pueden introducir artefactos. Su desactivación reduce el tiempo de procesamiento sin pérdida de precisión. Para documentos PDF digitales como los evaluados, este módulo es innecesario y puede introducir artefactos. Tabla 45. Tipología de errores observados. Tipo de error Frecuencia Ejemplo Causa probable Pérdida de acentos Alta más → mas Modelo de reconocimiento Duplicación de caracteres Media titulación → titulacióon Solapamiento de detecciones Confusión de puntuación Media ¿ → ? Caracteres similares Pérdida de eñe Baja año → ano Modelo de reconocimiento Texto desordenado Variable Mezcla de líneas Fallo de orientación Tabla 48. Tipología de errores observados. Tipo de error Frecuencia Ejemplo Causa probable Pérdida de acentos Alta más → mas Modelo de reconocimiento Duplicación de caracteres Media titulación → titulacióon Solapamiento de detecciones Confusión de puntuación Media ¿ → ? Caracteres similares Pérdida de eñe Baja año → ano Modelo de reconocimiento Texto desordenado Variable Mezcla de líneas Fallo de orientación Fuente: Elaboración propia. Tabla 46. Tasa de error por tipo de contenido. Tipo de contenido CER estimado Factor de riesgo Párrafos de texto ~1% Bajo Listas numeradas ~2% Medio Tablas simples ~3% Medio Encabezados + pie de página ~2% Medio Tablas complejas ~5% Alto Texto en columnas ~4% Alto Tabla 49. Tasa de error por tipo de contenido. Tipo de contenido CER estimado Factor de riesgo Párrafos de texto ~1% Bajo Listas numeradas ~2% Medio Tablas simples ~3% Medio Encabezados + pie de página ~2% Medio Tablas complejas ~5% Alto Texto en columnas ~4% Alto Fuente: Elaboración propia. Tabla 47. Cumplimiento de objetivos específicos. Objetivo Descripción Resultado Estado OE1 Comparar soluciones OCR EasyOCR, PaddleOCR, DocTR evaluados; PaddleOCR seleccionado ✓ Cumplido OE2 Preparar dataset de evaluación 24 páginas con ground truth ✓ Cumplido OE3 Identificar hiperparámetros críticos textline_orientation y text_det_thresh identificados ✓ Cumplido OE4 Optimizar con Ray Tune (≥50 trials) 64 trials ejecutados ✓ Cumplido OE5 Validar configuración optimizada CER: 7.78% → 1.49% documentado ✓ Cumplido Tabla 50. Cumplimiento de objetivos específicos. Objetivo Descripción Resultado Estado OE1 Comparar soluciones OCR EasyOCR, PaddleOCR, DocTR evaluados; PaddleOCR seleccionado ✓ Cumplido OE2 Preparar dataset de evaluación 45 páginas con ground truth ✓ Cumplido OE3 Identificar hiperparámetros críticos textline_orientation, use_doc_orientation_classify, text_det_thresh identificados ✓ Cumplido OE4 Optimizar con Ray Tune (≥50 trials) 64 trials ejecutados con GPU ✓ Cumplido OE5 Validar configuración optimizada CER: 8.85% → 7.72% (dataset), 0.79% (mejor trial) ✓ Parcial Fuente: Elaboración propia. Nota sobre OE5: El objetivo de CER < 2% se cumple en el mejor trial individual (0.79%). La validación sobre el dataset completo (7.72%) muestra que la generalización requiere mayor trabajo, identificándose como línea de trabajo futuro. 1. Tipo de documento único: Solo se evaluaron documentos académicos de UNIR. La configuración óptima puede no ser transferible a otros tipos de documentos (facturas, formularios, contratos). 1. Formato único: Solo se evaluaron PDFs digitales. Documentos escaneados o fotografías de documentos podrían beneficiarse de diferentes configuraciones. 1. Ground truth automático: El texto de referencia se extrajo programáticamente del PDF, lo cual puede introducir errores en layouts complejos donde el orden de lectura no es evidente. 1. Tamaño del dataset: 24 páginas es un dataset pequeño. Un dataset más amplio proporcionaría estimaciones más robustas. 1. Tamaño del dataset: 45 páginas es un dataset limitado. Un dataset más amplio proporcionaría estimaciones más robustas. 1. Parámetro fijo: text_det_unclip_ratio se mantuvo en 0.0 durante todo el experimento. Explorar este parámetro podría revelar mejoras adicionales. 1. Ejecución en CPU: Los tiempos reportados corresponden a ejecución en CPU. El comportamiento con GPU podría diferir. 1. Subconjunto de ajuste limitado: El ajuste de hiperparámetros se realizó sobre 5 páginas (páginas 5-10), lo que contribuyó al sobreajuste observado en la validación del dataset completo. 1. Sin validación cruzada: No se realizó validación cruzada sobre diferentes subconjuntos del dataset. 1. Sin test set independiente: El dataset de validación final se solapaba parcialmente con el de optimización. Para documentos académicos en español similares a los evaluados: Tabla 48. Configuración recomendada para PaddleOCR. Parámetro Valor Prioridad Justificación textline_orientation True Obligatorio Reduce CER en 69.7% text_det_thresh 0.45 (rango: 0.4-0.5) Recomendado Correlación fuerte con CER text_rec_score_thresh 0.6 (rango: 0.5-0.7) Recomendado Filtra reconocimientos poco confiables text_det_box_thresh 0.55 (rango: 0.5-0.6) Opcional Impacto moderado use_doc_orientation_classify False No recomendado Innecesario para PDFs digitales use_doc_unwarping False No recomendado Innecesario para PDFs digitales Tabla 51. Configuración recomendada para PaddleOCR con GPU. Parámetro Valor Prioridad Justificación textline_orientation True Obligatorio Crítico para layouts complejos use_doc_orientation_classify True Recomendado Mejora orientación de documento text_det_thresh 0.05 (rango: 0.04-0.10) Recomendado Detección sensible beneficia resultados text_det_box_thresh 0.49 (rango: 0.4-0.6) Recomendado Balance de confianza text_rec_score_thresh 0.57 (rango: 0.5-0.7) Opcional Filtra reconocimientos poco confiables use_doc_unwarping False No recomendado Innecesario para PDFs digitales Fuente: Elaboración propia. La optimización de hiperparámetros es recomendable cuando: 1. Sin GPU disponible: El fine-tuning requiere GPU; la optimización de hiperparámetros no. 1. Modelo preentrenado adecuado: El modelo ya soporta el idioma objetivo. 1. GPU disponible: Acelera significativamente la exploración del espacio de hiperparámetros (82× más rápido que CPU). 1. Modelo preentrenado adecuado: El modelo ya soporta el idioma objetivo (como PaddleOCR para español). 1. Dominio específico: Se busca optimizar para un tipo de documento particular. 1. Mejora incremental: El rendimiento baseline es aceptable pero mejorable. 1. Sin datos de entrenamiento: No se dispone de datasets etiquetados para fine-tuning. La optimización de hiperparámetros puede ser insuficiente cuando: 1. Idioma no soportado: El modelo no incluye el idioma en su vocabulario. 1. Escritura manuscrita: Requiere fine-tuning o modelos especializados. 1. Documentos muy degradados: Escaneos de baja calidad o documentos históricos. 1. Requisitos de CER < 0.5%: Puede requerir fine-tuning para alcanzar precisiones muy altas. Este capítulo ha presentado el desarrollo completo de la contribución: Planteamiento de la comparativa: · Evaluación de EasyOCR, PaddleOCR y DocTR · Selección de PaddleOCR por su configurabilidad Desarrollo de la comparativa: · 64 trials de Ray Tune con Optuna · Identificación de textline_orientation y text_det_thresh como críticos · CER mínimo alcanzado: 1.15% Discusión y análisis: · Mejora del CER de 7.78% a 1.49% (reducción del 80.9%) · Cumplimiento de todos los objetivos específicos · Identificación de limitaciones y recomendaciones prácticas Resultado principal: Se logró alcanzar el objetivo de CER < 2% mediante optimización de hiperparámetros, sin requerir fine-tuning ni recursos GPU. A lo largo de este capítulo se ha desarrollado el proceso completo de evaluación y optimización de sistemas OCR para documentos académicos en español. El benchmark comparativo inicial permitió seleccionar PaddleOCR como motor base gracias a su combinación de rendimiento y configurabilidad. La posterior optimización con Ray Tune y Optuna, ejecutada sobre 64 trials con aceleración GPU, identificó los parámetros críticos para maximizar el rendimiento: textline_orientation, use_doc_orientation_classify y text_det_thresh. Los resultados cuantifican tanto los logros como las limitaciones del enfoque. El mejor trial individual alcanzó un CER de 0.79%, cumpliendo holgadamente el objetivo de CER < 2%. Sin embargo, la validación sobre el dataset completo de 45 páginas reveló un CER de 7.72%, lo que representa una mejora del 12.8% respecto al baseline (8.85%) pero evidencia sobreajuste al subconjunto de optimización. Esta observación es valiosa: indica que futuros trabajos deberían emplear subconjuntos de optimización más representativos o aplicar técnicas de regularización. Desde el punto de vista práctico, la infraestructura dockerizada desarrollada y la aceleración GPU (82× más rápida que CPU) demuestran la viabilidad de esta metodología tanto para experimentación como para despliegue en producción. Fuentes de datos: · src/run_tuning.py: Script principal de optimización · src/results/: Resultados CSV de los trials · src/run_tuning.py: Script principal de optimización · src/results/raytune_paddle_results_20260119_122609.csv: Resultados CSV de PaddleOCR · src/results/raytune_easyocr_results_20260119_120204.csv: Resultados CSV de EasyOCR · src/results/raytune_doctr_results_20260119_121445.csv: Resultados CSV de DocTR Imágenes Docker: · seryus.ddns.net/unir/paddle-ocr-gpu: PaddleOCR con soporte GPU · seryus.ddns.net/unir/easyocr-gpu: EasyOCR con soporte GPU · seryus.ddns.net/unir/doctr-gpu: DocTR con soporte GPU Para evaluar la viabilidad práctica del enfoque optimizado en escenarios de producción, se realizó una validación adicional utilizando aceleración GPU. Esta fase complementa los experimentos en CPU presentados anteriormente y demuestra la aplicabilidad del método cuando se dispone de hardware con capacidad de procesamiento paralelo. · seryus.ddns.net/unir/paddle-ocr-gpu: PaddleOCR con soporte GPU · seryus.ddns.net/unir/easyocr-gpu: EasyOCR con soporte GPU · seryus.ddns.net/unir/doctr-gpu: DocTR con soporte GPU Esta sección presenta la comparación de rendimiento entre ejecución en CPU y GPU, justificando la elección de GPU para el experimento principal y demostrando el impacto práctico de la aceleración por hardware. Tabla 49. Especificaciones del entorno de validación GPU. Componente Especificación GPU NVIDIA GeForce RTX 3060 Laptop VRAM 5.66 GB CUDA 12.4 Sistema Operativo Ubuntu 24.04.3 LTS Kernel 6.14.0-37-generic Tabla 52. Especificaciones del entorno GPU utilizado. Componente Especificación GPU NVIDIA GeForce RTX 3060 Laptop VRAM 5.66 GB CUDA 12.4 Sistema Operativo Ubuntu 24.04.3 LTS Kernel 6.14.0-37-generic Fuente: Elaboración propia. El entorno de validación representa hardware de consumo típico para desarrollo de aplicaciones de machine learning, permitiendo evaluar el rendimiento en condiciones realistas de despliegue. Este hardware representa configuración típica de desarrollo, permitiendo evaluar el rendimiento en condiciones realistas de despliegue. Se evaluó el tiempo de procesamiento utilizando la configuración optimizada identificada en la fase anterior, comparando el rendimiento entre CPU y GPU. Tabla 50. Rendimiento comparativo CPU vs GPU. Métrica CPU GPU (RTX 3060) Factor de Aceleración Tiempo/Página 69.4s 0.55s 126x Dataset completo (45 páginas) ~52 min ~25 seg 126x Se comparó el tiempo de procesamiento entre CPU y GPU utilizando los datos de src/raytune_paddle_subproc_results_20251207_192320.csv (CPU) y src/results/raytune_paddle_results_20260119_122609.csv (GPU). Tabla 53. Rendimiento comparativo CPU vs GPU. Métrica CPU GPU (RTX 3060) Factor de Aceleración Tiempo/Página (promedio) 69.4s 0.84s 82x Dataset completo (45 páginas) ~52 min ~38 seg 82x 64 trials × 5 páginas ~6.4 horas ~1.5 horas 4.3x Fuente: Elaboración propia. La aceleración de 126x obtenida con GPU transforma la aplicabilidad práctica del sistema. Mientras que el procesamiento en CPU limita el uso a escenarios de procesamiento por lotes sin restricciones de tiempo, la velocidad con GPU habilita casos de uso interactivos y de tiempo real. Figura 15. Tiempo de procesamiento: CPU vs GPU (segundos/página) Fuente: Elaboración propia. Leyenda: Aceleración de 82× con GPU. El procesamiento de una página pasa de 69.4s (CPU) a 0.84s (GPU). La aceleración de 82× obtenida con GPU transforma la viabilidad del enfoque: · Optimización en CPU (6.4 horas): Viable pero lento para iteraciones rápidas · Optimización en GPU (1.5 horas): Permite explorar más configuraciones y realizar múltiples experimentos · Producción con GPU (0.84s/página): Habilita procesamiento en tiempo real PaddleOCR ofrece dos variantes de modelos: Mobile (optimizados para dispositivos con recursos limitados) y Server (mayor precisión a costa de mayor consumo de memoria). Se evaluó la viabilidad de ambas variantes en el hardware disponible. Tabla 51. Comparación de modelos Mobile vs Server en RTX 3060. Modelo VRAM Requerida Resultado Recomendación PP-OCRv5 Mobile 0.06 GB Funciona correctamente ✓ Recomendado PP-OCRv5 Server 5.3 GB OOM en página 2 ✗ Requiere >8 GB VRAM Tabla 54. Comparación de modelos Mobile vs Server en RTX 3060. Modelo VRAM Requerida Resultado Recomendación PP-OCRv5 Mobile 0.06 GB Funciona correctamente ✓ Recomendado PP-OCRv5 Server 5.3 GB OOM en página 2 ✗ Requiere >8 GB VRAM Fuente: Elaboración propia. Los modelos Server, a pesar de ofrecer potencialmente mayor precisión, resultan inviables en hardware con VRAM limitada (≤6 GB) debido a errores de memoria (Out of Memory). Los modelos Mobile, con un consumo de memoria 88 veces menor, funcionan de manera estable y ofrecen rendimiento suficiente para el caso de uso evaluado. La validación con aceleración GPU permite extraer las siguientes conclusiones: 1. Aceleración significativa: La GPU proporciona una aceleración de 126x sobre CPU, haciendo viable el procesamiento en tiempo real para aplicaciones interactivas. 1. Aceleración significativa: La GPU proporciona una aceleración de 82× sobre CPU, haciendo viable el procesamiento en tiempo real para aplicaciones interactivas. 1. Modelos Mobile recomendados: Para hardware con VRAM limitada (≤6 GB), los modelos Mobile de PP-OCRv5 ofrecen el mejor balance entre precisión y recursos, funcionando de manera estable sin errores de memoria. 1. Viabilidad práctica: Con GPU, el procesamiento de un documento completo (45 páginas) toma menos de 30 segundos, validando la aplicabilidad en entornos de producción donde el tiempo de respuesta es crítico. 1. Escalabilidad: La arquitectura de microservicios dockerizados utilizada para la validación GPU facilita el despliegue horizontal, permitiendo escalar el procesamiento según demanda. Esta validación demuestra que la configuración optimizada mediante Ray Tune no solo mejora la precisión (CER: 7.78% → 1.49%) sino que, combinada con aceleración GPU, resulta prácticamente aplicable en escenarios de producción real. Este capítulo resume las principales conclusiones del trabajo, evalúa el grado de cumplimiento de los objetivos planteados y propone líneas de trabajo futuro que permitirían ampliar y profundizar los resultados obtenidos.Best CER: 0.011535 (1.15%)
-Best WER: 0.098902 (9.89%)
+
Best CER: 0.007884 (0.79%)
+Best WER: 0.077848 (7.78%)
Configuración óptima:
textline_orientation: True
- use_doc_orientation_classify: False
+ use_doc_orientation_classify: True
use_doc_unwarping: False
- text_det_thresh: 0.4690
- text_det_box_thresh: 0.5412
+ text_det_thresh: 0.0462
+ text_det_box_thresh: 0.4862
text_det_unclip_ratio: 0.0
- text_rec_score_thresh: 0.6350
-
+ text_rec_score_thresh: 0.5658
+Análisis de Correlación
+
+
Impacto del Parámetro textline_orientation
+

Análisis de Fallos Catastróficos
+Comparación Baseline vs Optimizado
Evaluación sobre Dataset Completo
-
+Métricas de Mejora
-
+

Impacto Práctico
+Tiempo de Ejecución
-
+Resumen de la Sección
-Síntesis de la Optimización
+Discusión y análisis de resultados
Introducción
-Resumen Consolidado de Resultados
Progresión del Rendimiento
-
+
Comparación con Objetivo
-
+Análisis Detallado de Hiperparámetros
Jerarquía de Importancia
-
+
Análisis del Parámetro textline_orientation
Análisis del Parámetro text_det_thresh
+Parámetros sin Impacto Significativo
-Análisis de Parámetros de Preprocesamiento
+Análisis de Casos de Fallo
Clasificación de Errores
-
+Patrones de Fallo por Tipo de Contenido
-
+Comparación con Objetivos Específicos
-
+Limitaciones del Estudio
Limitaciones de Generalización
Limitaciones Metodológicas
Limitaciones de Validación
Implicaciones Prácticas
Guía de Configuración Recomendada
+Cuándo Aplicar Esta Metodología
Cuándo NO Aplicar Esta Metodología
Resumen del Capítulo
-Síntesis del Capítulo
+Validación con Aceleración GPU
-Comparativa de Rendimiento CPU vs GPU
+Configuración del Entorno GPU
-
+Comparación CPU vs GPU
-
+
Comparación de Modelos PaddleOCR
+Conclusiones de la Validación GPU
5.
Conclusiones
-y trabajo futuro
A lo largo de este trabajo se ha explorado la optimización de hiperparámetros como estrategia para mejorar el rendimiento de sistemas OCR sin necesidad de reentrenamiento. Las siguientes secciones evalúan el grado de cumplimiento de los objetivos planteados, sintetizan los hallazgos más relevantes y proponen direcciones para investigación futura.
Este Trabajo Fin de Máster ha demostrado que es posible mejorar significativamente el rendimiento de sistemas OCR preentrenados mediante optimización sistemática de hiperparámetros, sin requerir fine-tuning ni recursos GPU dedicados.
-El objetivo principal del trabajo era alcanzar un CER inferior al 2% en documentos académicos en español. Los resultados obtenidos confirman el cumplimiento de este objetivo:
-Tabla 52. Cumplimiento del objetivo de CER.
-Métrica | Objetivo | Resultado |
CER | < 2% | 1.49% |
Los resultados obtenidos confirman que la optimización sistemática de hiperparámetros constituye una alternativa viable al fine-tuning para mejorar sistemas OCR preentrenados. La infraestructura dockerizada con aceleración GPU desarrollada en este trabajo no solo facilita la experimentación reproducible, sino que reduce drásticamente los tiempos de ejecución, haciendo viable la exploración exhaustiva de espacios de configuración.
+El objetivo principal del trabajo era alcanzar un CER inferior al 2% en documentos académicos en español. Los resultados obtenidos se resumen a continuación:
+Tabla 55. Cumplimiento del objetivo de CER.
+Métrica | Objetivo | Mejor Trial | Dataset Completo | Cumplimiento |
CER | < 2% | 0.79% | 7.72% | ✓ Parcial |
Fuente: Elaboración propia.
Respecto a OE1 (Comparativa de soluciones OCR):
-· Se evaluaron tres soluciones OCR de código abierto: EasyOCR, PaddleOCR (PP-OCRv5) y DocTR
-· PaddleOCR demostró el mejor rendimiento base para documentos en español
-· La configurabilidad del pipeline de PaddleOCR lo hace idóneo para optimización
-Respecto a OE2 (Preparación del dataset):
-· Se construyó un dataset estructurado con 24 páginas de documentos académicos
-· La clase ImageTextDataset facilita la carga de pares imagen-texto
-· El ground truth se extrajo automáticamente del PDF mediante PyMuPDF
-Respecto a OE3 (Identificación de hiperparámetros críticos):
-· El parámetro textline_orientation es el más influyente: reduce el CER en un 69.7% cuando está habilitado
-· El umbral text_det_thresh presenta la correlación más fuerte (-0.52) con el CER
-· Los parámetros de corrección de documento (use_doc_orientation_classify, use_doc_unwarping) no aportan mejora en documentos digitales
-Respecto a OE4 (Optimización con Ray Tune):
-· Se ejecutaron 64 trials con el algoritmo OptunaSearch
-· El tiempo total del experimento fue aproximadamente 6 horas (en CPU)
-· La arquitectura basada en contenedores Docker permitió superar incompatibilidades entre Ray y los motores OCR, facilitando además la portabilidad y reproducibilidad
-Respecto a OE5 (Validación de la configuración):
-· Se validó la configuración óptima sobre el dataset completo de 24 páginas
-· La mejora obtenida fue del 80.9% en reducción del CER (7.78% → 1.49%)
-· La precisión de caracteres alcanzó el 98.51%
+Nota: El objetivo de CER < 2% se cumple en el mejor trial individual (0.79%, 5 páginas). La validación sobre el conjunto de datos completo (45 páginas) muestra un CER de 7.72%, evidenciando sobreajuste al subconjunto de optimización. Esta diferencia se analiza en detalle en el Capítulo 4.
+La evaluación comparativa de soluciones OCR (OE1) reveló diferencias significativas entre las tres alternativas analizadas. De las tres soluciones de código abierto evaluadas —EasyOCR, PaddleOCR (PP-OCRv5) y DocTR—, PaddleOCR demostró el mejor rendimiento base para documentos en español. Además, su arquitectura modular y la amplia configurabilidad de su pipeline lo convierten en el candidato idóneo para optimización mediante ajuste de hiperparámetros.
+En cuanto a la preparación del conjunto de datos (OE2), se construyó un corpus estructurado con 45 páginas de documentos académicos de UNIR. La implementación de la clase ImageTextDataset permite cargar de forma eficiente pares imagen-texto, mientras que el texto de referencia se extrajo automáticamente del PDF original mediante PyMuPDF, garantizando así la consistencia entre las imágenes y sus transcripciones esperadas.
+El análisis de hiperparámetros (OE3) arrojó resultados particularmente reveladores. El parámetro textline_orientation emergió como el factor más influyente, resultando crítico para obtener buenos resultados en documentos con diseños complejos. Asimismo, use_doc_orientation_classify demostró un impacto positivo en la configuración con GPU. Por otra parte, el umbral text_det_thresh presenta una correlación negativa moderada (-0.52) con el CER, lo que indica que valores más bajos tienden a mejorar el rendimiento, aunque con un límite inferior por debajo del cual el sistema falla catastróficamente. Cabe destacar que use_doc_unwarping no aporta mejora alguna en documentos digitales, ya que estos no presentan las deformaciones físicas para las que fue diseñado este módulo.
+La experimentación con Ray Tune (OE4) se completó satisfactoriamente mediante 64 trials ejecutados con el algoritmo OptunaSearch y aceleración GPU. El tiempo total del experimento —aproximadamente 1.5 horas con una GPU RTX 3060— demuestra la viabilidad práctica de esta aproximación. La arquitectura basada en contenedores Docker resultó esencial para superar las incompatibilidades entre Ray y los motores OCR, al tiempo que garantiza la portabilidad y reproducibilidad de los experimentos.
+Finalmente, la validación de la configuración óptima (OE5) se realizó sobre el conjunto de datos completo de 45 páginas. El mejor trial individual alcanzó un CER de 0.79%, equivalente a una precisión del 99.21%. Sin embargo, la evaluación sobre el conjunto de datos completo arrojó un CER de 7.72%, lo que representa una mejora del 12.8% respecto al baseline (8.85%), pero queda lejos del resultado del mejor trial. Esta diferencia revela un sobreajuste al subconjunto de optimización de 5 páginas, un fenómeno que se analiza en detalle en la sección de limitaciones.
1. Arquitectura sobre umbrales: Un único parámetro booleano (textline_orientation) tiene más impacto que todos los umbrales continuos combinados.
-1. Umbrales mínimos efectivos: Valores de text_det_thresh < 0.1 causan fallos catastróficos (CER >40%).
-1. Simplicidad para documentos digitales: Para documentos PDF digitales (no escaneados), los módulos de corrección de orientación y deformación son innecesarios.
-1. Optimización sin fine-tuning: Se puede mejorar significativamente el rendimiento de modelos preentrenados mediante ajuste de hiperparámetros de inferencia.
+El hallazgo más significativo de este trabajo es que las decisiones arquitectónicas tienen mayor impacto que los umbrales numéricos. Un único parámetro booleano —textline_orientation— influye más en el rendimiento final que todos los umbrales continuos combinados. Este resultado sugiere que, al optimizar sistemas OCR, conviene priorizar la exploración de configuraciones estructurales antes de ajustar finamente los valores numéricos.
+No obstante, los umbrales presentan límites operativos que deben respetarse. Valores de text_det_thresh inferiores a 0.1 provocan fallos catastróficos, con tasas de error que superan el 40%. Este comportamiento indica la existencia de regiones del espacio de hiperparámetros que deben evitarse, lo cual tiene implicaciones para el diseño de espacios de búsqueda en futuros experimentos.
+Otro hallazgo relevante es la innecesariedad de ciertos módulos para documentos digitales. Los PDF generados directamente desde procesadores de texto no presentan las deformaciones físicas —arrugas, curvaturas, rotaciones— para las que fueron diseñados los módulos de corrección. En estos casos, desactivar use_doc_unwarping no solo simplifica el pipeline, sino que puede mejorar el rendimiento al evitar procesamientos innecesarios.
+Finalmente, los resultados demuestran que es posible mejorar modelos preentrenados mediante ajuste exclusivo de hiperparámetros de inferencia, sin necesidad de reentrenamiento. Sin embargo, esta aproximación requiere validación cuidadosa, ya que las configuraciones optimizadas sobre subconjuntos pequeños pueden no generalizar a conjuntos de datos más amplios o diversos.
1. Metodología reproducible: Se documenta un proceso completo de optimización de hiperparámetros OCR con Ray Tune + Optuna.
-1. Análisis de hiperparámetros de PaddleOCR: Se cuantifica el impacto de cada parámetro configurable mediante correlaciones y análisis comparativo.
-1. Configuración óptima para español: Se proporciona una configuración validada para documentos académicos en español.
-1. Código fuente: Todo el código está disponible en el repositorio GitHub para reproducción y extensión.
+La principal contribución de este trabajo es una metodología reproducible para la optimización de hiperparámetros OCR. El proceso completo —desde la preparación del conjunto de datos hasta la validación de la configuración óptima— queda documentado y es replicable mediante las herramientas Ray Tune y Optuna.
+En segundo lugar, el análisis sistemático de los hiperparámetros de PaddleOCR constituye una contribución al conocimiento disponible sobre este motor OCR. Mediante el cálculo de correlaciones y análisis comparativo, se cuantifica el impacto de cada parámetro configurable, información que puede orientar futuros trabajos de optimización.
+Como resultado práctico, se aporta una configuración validada específicamente para documentos académicos en español. Aunque la generalización a otros tipos de documentos requiere validación adicional, esta configuración representa un punto de partida sólido para aplicaciones en el ámbito hispanohablante.
+Por último, todo el código fuente, las imágenes Docker y los datos experimentales están disponibles públicamente en el repositorio del proyecto, facilitando así la reproducción, verificación y extensión de este trabajo por parte de otros investigadores.
1. Tipo de documento único: Los experimentos se realizaron únicamente sobre documentos académicos de UNIR. La generalización a otros tipos de documentos requiere validación adicional.
-1. Tamaño del dataset: 24 páginas es un corpus limitado para conclusiones estadísticamente robustas.
-1. Ground truth automático: La extracción automática del texto de referencia puede introducir errores en layouts complejos.
-1. Validación en entorno limitado: Aunque se validó con GPU (126x más rápido que CPU, 0.55s/página), los experimentos se realizaron en hardware de consumo (RTX 3060). Hardware empresarial podría ofrecer mejor rendimiento.
-1. Parámetro no explorado: text_det_unclip_ratio permaneció fijo en 0.0 durante todo el experimento.
+Es necesario reconocer varias limitaciones que condicionan el alcance de las conclusiones presentadas. En primer lugar, todos los experimentos se realizaron sobre un único tipo de documento: textos académicos de UNIR. La generalización a otros formatos —facturas, formularios, documentos manuscritos— requeriría validación adicional con conjuntos de datos específicos.
+El tamaño del corpus constituye otra limitación relevante. Con 45 páginas, el conjunto de datos es modesto para extraer conclusiones estadísticamente robustas. Además, el subconjunto de optimización de tan solo 5 páginas resultó insuficiente para evitar el sobreajuste, como evidencia la brecha entre el CER del mejor trial (0.79%) y el resultado sobre el conjunto completo (7.72%).
+Desde el punto de vista metodológico, la extracción automática del texto de referencia mediante PyMuPDF puede introducir errores en documentos con diseños complejos, donde el orden de lectura no es evidente. Asimismo, el parámetro text_det_unclip_ratio permaneció fijo en 0.0 durante todo el experimento, dejando inexplorada una dimensión potencialmente relevante del espacio de hiperparámetros.
+Por último, aunque la GPU RTX 3060 utilizada proporcionó una aceleración de 82× respecto a la ejecución en CPU, se trata de hardware de consumo. Equipamiento empresarial con mayor capacidad de VRAM permitiría ejecutar múltiples servicios OCR simultáneamente y explorar espacios de búsqueda más amplios en menos tiempo.
1. Validación cruzada: Evaluar la configuración óptima en otros tipos de documentos en español (facturas, formularios, textos manuscritos).
-1. Exploración de text_det_unclip_ratio: Incluir este parámetro en el espacio de búsqueda.
-1. Dataset ampliado: Construir un corpus más amplio y diverso de documentos en español.
+Las limitaciones identificadas sugieren varias extensiones que podrían abordarse a corto plazo. La más urgente es la validación cruzada de la configuración óptima en otros tipos de documentos en español, como facturas, formularios administrativos o textos manuscritos. Esta validación revelaría el grado de transferibilidad de los hallazgos actuales.
+Para abordar el problema del sobreajuste, futuros experimentos deberían utilizar un subconjunto de optimización más amplio. Un conjunto de 15-20 páginas representativas reduciría la varianza y mejoraría la generalización de las configuraciones encontradas. Complementariamente, sería conveniente construir un corpus más amplio y diverso de documentos en español, incluyendo diferentes tipografías, diseños y calidades de imagen.
+Desde el punto de vista técnico, queda pendiente la exploración del parámetro text_det_unclip_ratio, que permaneció fijo en este trabajo. Incluirlo en el espacio de búsqueda podría revelar interacciones con otros parámetros actualmente desconocidas.
1. Transfer learning de hiperparámetros: Investigar si las configuraciones óptimas para un tipo de documento transfieren a otros dominios.
-1. Optimización multi-objetivo: Considerar simultáneamente CER, WER y tiempo de inferencia como objetivos.
-1. AutoML para OCR: Aplicar técnicas de AutoML más avanzadas (Neural Architecture Search, meta-learning).
-1. Comparación con fine-tuning: Cuantificar la brecha de rendimiento entre optimización de hiperparámetros y fine-tuning real.
+En un horizonte más amplio, surgen varias líneas de investigación prometedoras. Una de las más interesantes es el estudio del transfer learning de hiperparámetros: ¿las configuraciones óptimas para documentos académicos transfieren a otros dominios, o cada tipo de documento requiere optimización específica? La respuesta a esta pregunta tiene implicaciones prácticas significativas.
+Otra dirección valiosa es la optimización multi-objetivo, que considere simultáneamente CER, WER y tiempo de inferencia. En aplicaciones reales, la precisión máxima no siempre es el único criterio; a menudo existe un compromiso entre calidad y velocidad que debe gestionarse explícitamente.
+Técnicas de AutoML más avanzadas, como Neural Architecture Search o meta-learning, podrían automatizar aún más el proceso de configuración. Por último, una comparación rigurosa entre optimización de hiperparámetros y fine-tuning real cuantificaría la brecha de rendimiento entre ambas aproximaciones y ayudaría a decidir cuándo merece la pena el esfuerzo adicional del reentrenamiento.
1. Herramienta de configuración automática: Desarrollar una herramienta que determine automáticamente la configuración óptima para un nuevo tipo de documento.
-1. Integración en pipelines de producción: Implementar la configuración optimizada en sistemas reales de procesamiento documental.
-1. Benchmark público: Publicar un benchmark de OCR para documentos en español que facilite la comparación de soluciones.
+Los resultados de este trabajo abren camino a varias aplicaciones prácticas. Una herramienta de configuración automática podría analizar un pequeño conjunto de documentos de muestra y determinar la configuración óptima de PaddleOCR para ese tipo específico de documento, democratizando el acceso a estas técnicas de optimización.
+La integración de las configuraciones optimizadas en pipelines de producción representa otra aplicación natural. Los sistemas de procesamiento documental en organizaciones que manejan grandes volúmenes de documentos en español podrían beneficiarse directamente de los hallazgos de este trabajo.
+Finalmente, la publicación de un benchmark público de OCR para documentos en español facilitaría la comparación objetiva de diferentes soluciones. La comunidad hispanohablante carece actualmente de recursos comparables a los disponibles para otros idiomas, y este trabajo podría contribuir a llenar ese vacío.
Este trabajo demuestra que, en un contexto de recursos limitados donde el fine-tuning de modelos de deep learning no es viable, la optimización de hiperparámetros representa una alternativa práctica y efectiva para mejorar sistemas OCR.
-La metodología propuesta es reproducible, los resultados son cuantificables, y las conclusiones son aplicables a escenarios reales de procesamiento documental. La reducción del CER del 7.78% al 1.49% representa una mejora sustancial que puede tener impacto directo en aplicaciones downstream como extracción de información, análisis semántico y búsqueda de documentos.
-El código fuente y los datos experimentales están disponibles públicamente para facilitar la reproducción y extensión de este trabajo.
Referencias
+ En síntesis, este trabajo ha demostrado que la optimización de hiperparámetros representa una alternativa viable al fine-tuning para mejorar sistemas OCR, especialmente cuando se dispone de modelos preentrenados para el idioma objetivo y recursos limitados de tiempo o datos etiquetados. La metodología propuesta cumple los requisitos de reproducibilidad científica: los experimentos pueden replicarse, los resultados son cuantificables y las conclusiones son aplicables a escenarios reales de procesamiento documental. Sin embargo, la experiencia también ha puesto de manifiesto la importancia de diseñar cuidadosamente los experimentos de optimización. Aunque el objetivo de CER inferior al 2% se alcanzó en el mejor trial individual (0.79%), la validación sobre el conjunto de datos completo (7.72%) revela que el tamaño y representatividad del subconjunto de optimización son factores críticos que no deben subestimarse. La infraestructura dockerizada desarrollada constituye una aportación práctica que trasciende los resultados numéricos. Al encapsular los motores OCR en contenedores independientes, se resuelven problemas de compatibilidad entre dependencias y se garantiza que cualquier investigador pueda reproducir exactamente las condiciones experimentales. La aceleración de 82× proporcionada por GPU transforma lo que sería un experimento de días en uno de horas, haciendo viable la exploración exhaustiva de espacios de hiperparámetros con hardware de consumo. El código fuente, las imágenes Docker y los datos experimentales están disponibles públicamente en el repositorio del proyecto. Esta apertura busca facilitar no solo la reproducción de los resultados, sino también la extensión de este trabajo hacia nuevos tipos de documentos, idiomas o motores OCR. Akiba, T., Sano, S., Yanase, T., Ohta, T., & Koyama, M. (2019). Optuna: A next-generation hyperparameter optimization framework. Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, 2623-2631. https://doi.org/10.1145/3292500.3330701 Baek, Y., Lee, B., Han, D., Yun, S., & Lee, H. (2019). Character region awareness for text detection. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 9365-9374. https://doi.org/10.1109/CVPR.2019.00959 Bergstra, J., & Bengio, Y. (2012). Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(1), 281-305. https://jmlr.org/papers/v13/bergstra12a.html
Zoph, B., & Le, Q. V. (2017). Neural architecture search with reinforcement learning. International Conference on Learning Representations (ICLR). https://arxiv.org/abs/1611.01578
Anexo A. -Código fuente y datos analizados
El código fuente completo y los datos utilizados en este trabajo están disponibles en el siguiente repositorio:
-URL del repositorio: https://github.com/seryus/MastersThesis
+Código fuente y datos analizadosEste anexo proporciona la información técnica necesaria para reproducir los experimentos descritos en este trabajo. Se incluyen las instrucciones de instalación, configuración de los servicios OCR dockerizados, ejecución de los scripts de optimización y acceso a los resultados experimentales.
+Todo el código fuente y los datos utilizados en este trabajo están disponibles públicamente en el siguiente repositorio:
+URL del repositorio: https://seryus.ddns.net/unir/MastersThesis
El repositorio incluye:
· Servicios OCR dockerizados: PaddleOCR, DocTR, EasyOCR con soporte GPU
· Scripts de evaluación: Herramientas para evaluar y comparar modelos OCR
@@ -5657,83 +5727,78 @@ major-latin;mso-bidi-font-family:"Calibri Light";mso-bidi-theme-font:major-latin· Dataset: Imágenes y textos de referencia utilizados
· Resultados: Archivos CSV con los resultados de los 64 trials por servicio
MastersThesis/
-├── docs/ # Documentación de la tesis
-│ └── metrics/ # Métricas de rendimiento OCR
-│ ├── metrics.md # Resumen comparativo
-│ ├── metrics_paddle.md # Resultados PaddleOCR
-│ ├── metrics_doctr.md # Resultados DocTR
-│ └── metrics_easyocr.md # Resultados EasyOCR
-├── src/
-│ ├── paddle_ocr/ # Servicio PaddleOCR
-│ │ ├── Dockerfile.gpu # Imagen Docker GPU
-│ │ ├── Dockerfile.cpu # Imagen Docker CPU
-│ │ ├── docker-compose.yml # Configuración Docker
-│ │ └── main.py # API FastAPI
-│ ├── doctr_service/ # Servicio DocTR
-│ │ ├── Dockerfile.gpu
-│ │ ├── docker-compose.yml
-│ │ └── main.py
-│ ├── easyocr_service/ # Servicio EasyOCR
-│ │ ├── Dockerfile.gpu
-│ │ ├── docker-compose.yml
-│ │ └── main.py
-│ ├── dataset/ # Dataset de evaluación
-│ ├── raytune_ocr.py # Utilidades compartidas Ray Tune
-│ └── results/ # Resultados de ajuste CSV
-└── .gitea/workflows/ci.yaml # Pipeline CI/CD
Figura 16. Estructura del repositorio MastersThesis
+
Fuente: Elaboración propia.
+Tabla 56. Descripción de directorios principales.
+Directorio | Contenido |
docs/ | Capítulos del TFM en Markdown (estructura UNIR) |
docs/metrics/ | Métricas de rendimiento por servicio OCR |
src/paddle_ocr/ | Servicio PaddleOCR dockerizado |
src/doctr_service/ | Servicio DocTR dockerizado |
src/easyocr_service/ | Servicio EasyOCR dockerizado |
src/raytune/ | Scripts de optimización Ray Tune |
src/results/ | CSVs con resultados de 64 trials por servicio |
thesis_output/ | Documento TFM generado + figuras PNG |
instructions/ | Plantilla e instrucciones UNIR oficiales |
Fuente: Elaboración propia.
+Tabla 53. Especificaciones del sistema de desarrollo.
-Componente | Especificación |
Sistema Operativo | Ubuntu 24.04.3 LTS |
CPU | AMD Ryzen 7 5800H |
RAM | 16 GB DDR4 |
GPU | NVIDIA RTX 3060 Laptop (5.66 GB VRAM) |
CUDA | 12.4 |
Tabla 57. Especificaciones del sistema de desarrollo.
+Componente | Especificación |
Sistema Operativo | Ubuntu 24.04.3 LTS |
CPU | AMD Ryzen 7 5800H |
RAM | 16 GB DDR4 |
GPU | NVIDIA RTX 3060 Laptop (5.66 GB VRAM) |
CUDA | 12.4 |
Fuente: Elaboración propia.
Tabla 54. Dependencias del proyecto.
-Componente | Versión |
Python | 3.12.3 |
Docker | 29.1.5 |
NVIDIA Container Toolkit | Requerido para GPU |
Ray | 2.52.1 |
Optuna | 4.7.0 |
Tabla 58. Dependencias del proyecto.
+Componente | Versión |
Python | 3.12.3 |
Docker | 29.1.5 |
NVIDIA Container Toolkit | Requerido para GPU |
Ray | 2.52.1 |
Optuna | 4.7.0 |
Fuente: Elaboración propia.
Imágenes Docker:
-· GPU: seryus.ddns.net/unir/paddle-ocr-gpu
-· CPU: seryus.ddns.net/unir/paddle-ocr-cpu
-· GPU: seryus.ddns.net/unir/paddle-ocr-gpu · CPU: seryus.ddns.net/unir/paddle-ocr-cpu Imagen Docker: seryus.ddns.net/unir/doctr-gpu Imagen Docker: seryus.ddns.net/unir/doctr-gpu Imagen Docker: seryus.ddns.net/unir/easyocr-gpu Nota: EasyOCR utiliza el mismo puerto (8002) que PaddleOCR. No se pueden ejecutar simultáneamente. Por esta razón, existe un archivo docker-compose separado para EasyOCR. Imagen Docker: seryus.ddns.net/unir/easyocr-gpu Tabla 55. Servicios Docker y puertos. Servicio Puerto Script de Ajuste PaddleOCR 8002 paddle_ocr_payload DocTR 8003 doctr_payload EasyOCR 8002 easyocr_payload Tabla 59. Servicios Docker y puertos. Servicio Puerto Script de Ajuste Nota PaddleOCR 8002 paddle_ocr_payload - DocTR 8003 doctr_payload - EasyOCR 8002 easyocr_payload Conflicto con PaddleOCR Fuente: Elaboración propia. Nota: Debido a limitaciones de recursos GPU (VRAM insuficiente para ejecutar múltiples modelos OCR simultáneamente), solo se ejecuta un servicio a la vez. PaddleOCR y EasyOCR comparten el puerto 8002. Para cambiar de servicio, detener el actual con docker compose down. Los resultados detallados de las evaluaciones y ajustes de hiperparámetros se encuentran en: · Métricas Generales - Comparativa de los tres servicios · PaddleOCR - Mejor precisión (7.76% CER baseline, 1.49% optimizado) · DocTR - Más rápido (0.50s/página) · EasyOCR - Balance intermedio Tabla 56. Resumen de resultados del benchmark por servicio. Servicio CER Base CER Ajustado Mejora PaddleOCR 8.85% 7.72% 12.8% DocTR 12.06% 12.07% 0% EasyOCR 11.23% 11.14% 0.8% Esta sección presenta los resultados completos de las evaluaciones comparativas y del ajuste de hiperparámetros realizado con Ray Tune sobre los tres servicios OCR evaluados. Tabla 60. Comparativa de servicios OCR en dataset de 45 páginas (GPU RTX 3060). Servicio CER WER Tiempo/Página Tiempo Total VRAM PaddleOCR (Mobile) 7.76% 11.62% 0.58s 32.0s 0.06 GB EasyOCR 11.23% 36.36% 1.88s 88.5s ~2 GB DocTR 12.06% 42.01% 0.50s 28.4s ~1 GB Fuente: Elaboración propia. Ganador: PaddleOCR (Mobile) - Mejor precisión (7.76% CER) con velocidad competitiva y mínimo consumo de VRAM. Se ejecutaron 64 trials por servicio utilizando Ray Tune con Optuna sobre las páginas 5-10 del primer documento. Tabla 61. Resultados del ajuste de hiperparámetros por servicio. Servicio CER Base CER Ajustado Mejora Mejor Trial (5 páginas) PaddleOCR 8.85% 7.72% 12.8% 0.79% ✓ DocTR 12.06% 12.07% 0% 7.43% EasyOCR 11.23% 11.14% 0.8% 5.83% Fuente: Elaboración propia. Nota sobre sobreajuste: La diferencia entre los resultados del mejor trial (subconjunto de 5 páginas) y el dataset completo (45 páginas) indica sobreajuste parcial a las páginas de ajuste. Un subconjunto más grande (15-20 páginas) mejoraría la generalización. La siguiente configuración logró el mejor rendimiento en el ajuste de hiperparámetros: Hallazgos clave: · textline_orientation=true: Crítico para documentos con layouts mixtos · use_doc_orientation_classify=true: Mejora detección de orientación · use_doc_unwarping=false: Innecesario para PDFs digitales · text_det_thresh bajo (0.0462): Detección más sensible mejora resultados Tabla 62. Comparación de rendimiento CPU vs GPU (PaddleOCR). Métrica CPU GPU (RTX 3060) Aceleración Tiempo/Página 69.4s 0.55s 126x más rápido Mejor CER 1.15% 0.79% GPU mejor 45 páginas ~52 min ~25 seg 126x más rápido Fuente: Elaboración propia. Tabla 63. Tipos de errores identificados por servicio OCR. Servicio Fortalezas Debilidades ¿Fine-tuning recomendado? PaddleOCR Preserva estructura, buen manejo de español Errores menores de acentos (~5%) No (ya excelente) DocTR Más rápido Pierde estructura, omite TODOS los diacríticos Sí (para diacríticos) EasyOCR Modelo correcto para español Caracteres espurios, confunde o/0 Sí (problemas del detector) Fuente: Elaboración propia. Los resultados crudos de los 64 trials por servicio están disponibles en el repositorio: Tabla 64. Ubicación de archivos de resultados. Servicio Archivo CSV PaddleOCR DocTR EasyOCR Fuente: Elaboración propia.
+
+
+
+
+
+
+
+ Sergio
+Jimnez Jimnez Optimizacin
+de Hiperparmetros OCR con Ray Tune para Documentos Acadmicos en Espaol 13 cd src/paddle_ocr
+
cd src/paddle_ocr
# GPU (recomendado)
docker compose up -d
-# CPU (más lento, 126x)
-docker compose -f docker-compose.cpu-registry.yml up -d
+# CPU (más lento, 82x)
+docker compose -f docker-compose.cpu-registry.yml up -d
+DocTR (Puerto 8003)
-cd src/doctr_service
+
cd src/doctr_service
# GPU
-docker compose up -d
+docker compose up -d
+EasyOCR (Puerto 8002)
-cd src/easyocr_service
+
cd src/easyocr_service
-# GPU
-docker compose up -d
+# GPU (usar archivo separado para evitar conflicto de puerto)
+docker compose up -d
+Verificar Estado del Servicio
-# Verificar salud del servicio
+
# Verificar salud del servicio
curl http://localhost:8002/health
# Respuesta esperada:
-# {"status": "ok", "model_loaded": true, "gpu_name": "NVIDIA GeForce RTX 3060"}
+# {"status": "ok", "model_loaded": true, "gpu_name": "NVIDIA GeForce RTX 3060"}
+A.5 Uso de la API OCR
Evaluar Dataset Completo
-# PaddleOCR - Evaluación completa
+
# PaddleOCR - Evaluación completa
curl -X POST http://localhost:8002/evaluate_full \
-H "Content-Type: application/json" \
-d '{
"pdf_folder": "/app/dataset",
"save_output": true
- }'
+ }'
+Evaluar con Hiperparámetros Optimizados
-# PaddleOCR con configuración óptima
+
# PaddleOCR con configuración óptima
curl -X POST http://localhost:8002/evaluate_full \
-H "Content-Type: application/json" \
-d '{
@@ -5746,10 +5811,12 @@ curl -X POST http://localhost:8002/evaluate_full \
"text_det_unclip_ratio": 0.0,
"text_rec_score_thresh": 0.5658,
"save_output": true
- }'
+ }'
+A.6 Ajuste de Hiperparámetros con Ray Tune
Ejecutar Ajuste
-cd src
+
cd src
# Activar entorno virtual
source ../.venv/bin/activate
@@ -5763,21 +5830,61 @@ check_workers(ports, 'PaddleOCR')
trainable = create_trainable(ports, paddle_ocr_payload)
results = run_tuner(trainable, PADDLE_OCR_SEARCH_SPACE, num_samples=64)
analyze_results(results, prefix='raytune_paddle', config_keys=PADDLE_OCR_CONFIG_KEYS)
-"
+"
+Servicios y Puertos
-
+A.7 Métricas de Rendimiento
-Resumen de Resultados
-
+Comparativa General de Servicios
+Resultados de Ajuste de Hiperparámetros
+Configuración Óptima PaddleOCR
+{
+ "use_doc_orientation_classify": true,
+ "use_doc_unwarping": false,
+ "textline_orientation": true,
+ "text_det_thresh": 0.0462,
+ "text_det_box_thresh": 0.4862,
+ "text_det_unclip_ratio": 0.0,
+ "text_rec_score_thresh": 0.5658
+}
+Rendimiento CPU vs GPU
+Análisis de Errores por Servicio
+Archivos de Resultados
+A.8 Licencia
diff --git a/thesis_output/plantilla_individual_files/colorschememapping.xml b/thesis_output/plantilla_individual_files/colorschememapping.xml
new file mode 100644
index 0000000..b200daa
--- /dev/null
+++ b/thesis_output/plantilla_individual_files/colorschememapping.xml
@@ -0,0 +1,2 @@
+
+
+
+
+
+
+
+
+
+