# Objetivos concretos y metodología de trabajo

Este capítulo establece los objetivos del trabajo siguiendo la metodología SMART (Doran, 1981) y describe la metodología experimental empleada para alcanzarlos. Se define un objetivo general y cinco objetivos específicos, todos ellos medibles y verificables.

## Objetivo general

> **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.**

### Justificación SMART del Objetivo General

**Tabla 4.** *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 |

*Fuente: Elaboración propia.*

## Objetivos específicos

### OE1: Comparar soluciones OCR de código abierto
> **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.**

### OE2: Preparar un dataset de evaluación
> **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.**

### OE3: Identificar hiperparámetros críticos
> **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.**

### OE4: Optimizar hiperparámetros con Ray Tune
> **Ejecutar una búsqueda automatizada de hiperparámetros utilizando Ray Tune con Optuna, evaluando al menos 50 configuraciones diferentes.**

### OE5: Validar la configuración optimizada
> **Comparar el rendimiento de la configuración baseline versus la configuración optimizada sobre el dataset completo, documentando la mejora obtenida.**

## Metodología del trabajo

### Visión General



```mermaid
---
title: "Fases de la metodología experimental"
---
flowchart LR
    A["Fase 1<br/>Dataset"] --> B["Fase 2<br/>Benchmark"] --> C["Fase 3<br/>Espacio"] --> D["Fase 4<br/>Optimización"] --> E["Fase 5<br/>Validación"]
```

**Descripción de las fases:**

- **Fase 1 - Preparación del Dataset**: Conversión PDF a imágenes (300 DPI), extracción de ground truth con PyMuPDF
- **Fase 2 - Benchmark Comparativo**: Evaluación de EasyOCR, PaddleOCR, DocTR con métricas CER/WER
- **Fase 3 - Espacio de Búsqueda**: Identificación de hiperparámetros y configuración de Ray Tune + Optuna
- **Fase 4 - Optimización**: Ejecución de 64 trials con paralelización (2 concurrentes)
- **Fase 5 - Validación**: Comparación baseline vs optimizado, análisis de correlaciones

### Fase 1: Preparación del Dataset

#### Fuente de Datos
Se utilizaron documentos PDF académicos de UNIR (Universidad Internacional de La Rioja), específicamente las instrucciones para la elaboración del TFE del Máster en Inteligencia Artificial.

#### Proceso de Conversión
El script `prepare_dataset.ipynb` implementa:

1. **Conversión PDF a imágenes**:
   - Biblioteca: PyMuPDF (fitz)
   - Resolución: 300 DPI
   - Formato de salida: PNG

2. **Extracción de texto de referencia**:
   - 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ínea

#### Estructura del Dataset

```mermaid
---
title: "Estructura del dataset de evaluación"
---
flowchart LR
    dataset["dataset/"] --> d0["0/"]

    d0 --> pdf["instrucciones.pdf"]

    d0 --> img["img/"]
    img --> img1["page_0001.png"]
    img --> img2["page_0002.png"]
    img --> imgN["..."]

    d0 --> txt["txt/"]
    txt --> txt1["page_0001.txt"]
    txt --> txt2["page_0002.txt"]
    txt --> txtN["..."]

    dataset --> dots["..."]
```

#### Clase ImageTextDataset

Se implementó una clase Python para cargar pares imagen-texto:

```python
class ImageTextDataset:
    def __init__(self, root):
        # Carga pares (imagen, texto) de carpetas pareadas

    def __getitem__(self, idx):
        # Retorna (PIL.Image, str)
```

### Fase 2: Benchmark Comparativo

#### Modelos Evaluados

**Tabla 5.** *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 |

*Fuente: Elaboración propia.*

#### Métricas de Evaluación

Se utilizó la biblioteca `jiwer` para calcular:

```python
from jiwer import wer, cer

def evaluate_text(reference, prediction):
    return {
        'WER': wer(reference, prediction),
        'CER': cer(reference, prediction)
    }
```

### Fase 3: Espacio de Búsqueda

#### Hiperparámetros Seleccionados

**Tabla 6.** *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 |

*Fuente: Elaboración propia.*

#### Configuración de Ray Tune

```python
from ray import tune
from ray.tune.search.optuna import OptunaSearch

search_space = {
    "use_doc_orientation_classify": tune.choice([True, False]),
    "use_doc_unwarping": tune.choice([True, False]),
    "textline_orientation": tune.choice([True, False]),
    "text_det_thresh": tune.uniform(0.0, 0.7),
    "text_det_box_thresh": tune.uniform(0.0, 0.7),
    "text_det_unclip_ratio": tune.choice([0.0]),
    "text_rec_score_thresh": tune.uniform(0.0, 0.7),
}

tuner = tune.Tuner(
    trainable_paddle_ocr,
    tune_config=tune.TuneConfig(
        metric="CER",
        mode="min",
        search_alg=OptunaSearch(),
        num_samples=64,
        max_concurrent_trials=2
    )
)
```

### Fase 4: Ejecución de Optimización

#### Arquitectura de Ejecución

Debido a incompatibilidades entre Ray y PaddleOCR en el mismo proceso, se implementó una arquitectura basada en subprocesos:

```mermaid
---
title: "Arquitectura de ejecución con subprocesos"
---
flowchart LR
    A["Ray Tune (proceso principal)"]

    A --> B["Subprocess 1: paddle_ocr_tuning.py --config"]
    B --> B_out["Retorna JSON con métricas"]

    A --> C["Subprocess 2: paddle_ocr_tuning.py --config"]
    C --> C_out["Retorna JSON con métricas"]
```

#### Script de Evaluación (paddle_ocr_tuning.py)

El script recibe hiperparámetros por línea de comandos:

```bash
python paddle_ocr_tuning.py \
    --pdf-folder ./dataset \
    --textline-orientation True \
    --text-det-box-thresh 0.5 \
    --text-det-thresh 0.4 \
    --text-rec-score-thresh 0.6
```

Y retorna métricas en formato JSON:

```json
{
    "CER": 0.0125,
    "WER": 0.1040,
    "TIME": 331.09,
    "PAGES": 5,
    "TIME_PER_PAGE": 66.12
}
```

### Fase 5: Validación

#### Protocolo de Validación

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
4. **Métricas reportadas**: CER, WER, tiempo de procesamiento

### Entorno de Ejecución

#### Hardware

**Tabla 7.** *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 |

*Fuente: Elaboración propia.*

#### Software

**Tabla 8.** *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 |

*Fuente: Elaboración propia.*

### Limitaciones Metodológicas

1. **Tamaño del dataset**: El dataset contiene 24 páginas de un único tipo de documento. Resultados pueden no generalizar a otros formatos.

2. **Ejecución en CPU**: Los tiempos de procesamiento (~70s/página) serían significativamente menores con GPU.

3. **Ground truth imperfecto**: El texto de referencia extraído de PDF puede contener errores en documentos con layouts complejos.

4. **Parámetro fijo**: `text_det_unclip_ratio` quedó fijado en 0.0 durante todo el experimento por decisión de diseño inicial.

## Resumen del capítulo

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.

