Clasificador de Documentos con IA

Proyecto Final - Maestría en IoT y AI

Autor: LEONI
Materia: Inteligencia Artificial
Fecha: Noviembre 2025

---

📋 Descripción del Proyecto

Este proyecto implementa un sistema de clasificación automática de documentos utilizando técnicas de Procesamiento de Lenguaje Natural (NLP) y Machine Learning. El sistema es capaz de clasificar documentos escaneados (archivos .tif) en 16 categorías:

1. Advertisement (publicidad)
2. Budget (presupuestos)
3. Email (correos electrónicos)
4. File Folder (carpetas de archivos)
5. Form (formularios)
6. Handwritten (documentos manuscritos)
7. Invoice (facturas)
8. Letter (cartas)
9. Memo (memorandos)
10. News Article (artículos de noticias)
11. Presentation (presentaciones)
12. Questionnaire (cuestionarios)
13. Resume (currículums vitae)
14. Scientific Publication (publicaciones científicas)
15. Scientific Report (reportes científicos)
16. Specification (especificaciones técnicas)

El pipeline completo incluye:

• Extracción de texto mediante OCR (Tesseract) directamente desde archivos .tif
• Preprocesamiento avanzado de texto con NLP
• Análisis exploratorio exhaustivo de datos
• Entrenamiento y evaluación de múltiples modelos de ML
• Validación cruzada y detección de overfitting
• Deployment del mejor modelo

---

🎯 Objetivos del Proyecto

Objetivos Principales

1. Desarrollar un clasificador robusto de documentos basado en imágenes
2. Implementar un pipeline completo de ML desde datos raw hasta deployment
3. Aplicar técnicas avanzadas de NLP para feature engineering
4. Realizar análisis comparativo de múltiples algoritmos de ML
5. Validar la generalización del modelo mediante cross-validation

Criterios de Evaluación (según rúbrica del proyecto)

• ✅ Selección y justificación de representación/features: TF-IDF con n-gramas
• ✅ Selección y justificación de algoritmos: 5 modelos evaluados comparativamente
• ✅ Análisis exploratorio exhaustivo: EDA completo con visualizaciones
• ✅ Argumentación de decisiones: Cada paso está documentado y justificado
• ✅ Evaluación de PCA: Análisis de necesidad y decisión fundamentada
• ✅ Detección de overfitting: Cross-validation con 5-folds y métricas train/val

---

🛠️ Tecnologías y Librerías Utilizadas

Procesamiento de Imágenes y OCR

• PIL (Pillow): Carga y manipulación de imágenes TIF
• Tesseract OCR: Extracción de texto de imágenes (soporta .tif nativamente)

Procesamiento de Lenguaje Natural

• NLTK: Tokenización, lemmatización, stopwords
• sklearn.feature_extraction.text: TF-IDF vectorization
• WordCloud: Visualización de vocabulario

Machine Learning

• scikit-learn: Modelos, métricas, validación cruzada
  • Logistic Regression
  • Multinomial Naive Bayes
  • Linear SVM (LinearSVC)
  • Random Forest
• XGBoost: Gradient boosting
• LightGBM: Gradient boosting optimizado

Análisis y Visualización

• pandas: Manipulación de datos
• numpy: Operaciones numéricas
• matplotlib: Visualizaciones
• seaborn: Visualizaciones estadísticas avanzadas

---

📁 Estructura del Proyecto

Proyecto_AI/
│
├── main.ipynb                          # Notebook principal con todo el código
├── example.ipynb                       # Notebook de referencia/ejemplo
├── README.md                           # Este archivo
│
├── datasets/
│   └── document-classification-dataset-xl/   # Dataset con 16 clases
│       ├── advertisement/              # Publicidades
│       ├── budget/                     # Presupuestos
│       ├── email/                      # Emails
│       ├── file_folder/                # Carpetas
│       ├── form/                       # Formularios
│       ├── handwritten/                # Manuscritos
│       ├── invoice/                    # Facturas
│       ├── letter/                     # Cartas
│       ├── memo/                       # Memorandos
│       ├── news_article/               # Artículos de noticias
│       ├── presentation/               # Presentaciones
│       ├── questionnaire/              # Cuestionarios
│       ├── resume/                     # CVs
│       ├── scientific_publication/     # Publicaciones científicas
│       ├── scientific_report/          # Reportes científicos
│       └── specification/              # Especificaciones técnicas
│
└── models/                             # Modelos entrenados (generado)
    ├── model_latest.pkl                # Mejor modelo entrenado
    ├── vectorizer_latest.pkl           # Vectorizador TF-IDF
    └── metadata_latest.json            # Metadatos del modelo

---

🚀 Instalación y Configuración

Requisitos Previos

• Python 3.8+
• Tesseract OCR instalado en el sistema

1. Instalar Tesseract OCR

Windows:

# Descargar e instalar desde:
https://github.com/UB-Mannheim/tesseract/wiki

# Por defecto se instala en:
C:\Program Files\Tesseract-OCR\tesseract.exe

Linux (Ubuntu/Debian):

sudo apt-get update
sudo apt-get install tesseract-ocr

macOS:

brew install tesseract

2. Instalar Dependencias de Python

# Crear entorno virtual (recomendado)
conda create -n proyecto_ai python=3.9
conda activate proyecto_ai

# Instalar librerías
pip install pandas numpy matplotlib seaborn
pip install nltk pytesseract pillow
pip install scikit-learn xgboost lightgbm
pip install wordcloud imbalanced-learn

3. Descargar Recursos de NLTK

import nltk
nltk.download('stopwords')
nltk.download('punkt')
nltk.download('wordnet')
nltk.download('omw-1.4')

4. Configurar Ruta de Tesseract

En el notebook main.ipynb, ajustar la ruta según tu instalación:

pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'

---

📊 Pipeline del Proyecto

PASO 1: Extracción de Texto con OCR

Proceso:

1. Cargar imagen TIF directamente con PIL (Tesseract soporta .tif nativamente)
2. Aplicar Tesseract OCR para extraer texto
3. Preprocesar texto con NLP
4. Almacenar en DataFrame estructurado

Ventaja de usar archivos TIF directamente:

• Tesseract OCR puede procesar archivos .tif sin necesidad de conversión
• Ahorra tiempo de procesamiento y espacio en disco
• Mantiene la calidad original de la imagen

Preprocesamiento de Texto:

La función preprocess_data() realiza las siguientes transformaciones:

1. Lowercase: Normaliza el texto
2. Eliminación de saltos de línea y tabulaciones: Limpia formato OCR
3. Normalización de espacios: Elimina espacios múltiples
4. Eliminación de números: Reduce ruido (valores específicos no son relevantes)
5. Eliminación de puntuación: Reduce dimensionalidad sin perder semántica
6. Tokenización: Divide texto en palabras individuales
7. Eliminación de stopwords: Elimina palabras comunes sin valor discriminativo
8. Lemmatización: Reduce palabras a forma base (running → run)

Justificación de Lemmatización vs Stemming:

• Lemmatización preserva palabras reales (mejor interpretabilidad)
• Stemming es más agresivo pero puede generar tokens sin significado
• Para clasificación de documentos, preferimos interpretabilidad

---

PASO 2: Análisis Exploratorio de Datos (EDA)

2.1 Análisis de Balance de Clases

Métricas calculadas:

• Conteo absoluto y porcentaje por clase
• Ratio de desbalance (clase_max / clase_min)
• Recomendaciones según nivel de desbalance

Criterios de balance:

• Balanceado: ratio < 1.2:1
• Ligeramente desbalanceado: 1.2:1 - 1.5:1
• Moderadamente desbalanceado: 1.5:1 - 2.0:1
• Severamente desbalanceado: > 2.0:1

Visualizaciones:

• Gráfico de barras (valores absolutos)
• Gráfico de pastel (proporciones)

3.2 Análisis de Longitud de Texto

Objetivo: Identificar si la longitud del texto es un feature discriminativo

Análisis realizado:

• Estadísticas descriptivas por clase (media, std, min, max)
• Boxplot para identificar outliers
• Histograma superpuesto para comparar distribuciones
• Violin plot para visualizar densidad

Insight esperado:

• Diferentes tipos de documentos tienen longitudes características
• Emails y memos tienden a ser más cortos
• Publicaciones científicas y reportes tienden a ser más largos
• Formularios y facturas tienen longitud variable

2.3 Análisis de Vocabulario

Funciones:

• Identificación de palabras más frecuentes por clase
• Generación de word clouds visuales
• Detección de vocabulario discriminativo

Utilidad:

• Validar que OCR funciona correctamente
• Identificar palabras clave características de cada clase (ej: "invoice" en facturas, "research" en papers)
• Detectar posibles problemas (palabras incorrectas por OCR deficiente)

---

PASO 3: División Estratificada de Datos

División: 70% Train - 20% Validation - 10% Test

Justificación:

• 70% Entrenamiento: Suficiente datos para aprendizaje
• 20% Validación: Ajustar hiperparámetros sin contaminar test
• 10% Test: Evaluación final con datos nunca vistos

Estratificación:

• Mantiene la proporción de las 16 clases en cada conjunto
• Crítico para datasets con múltiples clases
• Asegura representatividad estadística

Proceso de división:

# Primero: separar test (10%)
X_temp, X_test, y_temp, y_test = train_test_split(
    X, y, test_size=0.10, stratify=y
)

# Segundo: dividir resto en train (70%) y validation (20%)
X_train, X_val, y_train, y_val = train_test_split(
    X_temp, y_temp, test_size=0.222, stratify=y_temp  # 20% del total = 22.2% del 90%
)

---

PASO 4: Feature Engineering - TF-IDF

¿Qué es TF-IDF?

• TF (Term Frequency): Frecuencia de término en documento
• IDF (Inverse Document Frequency): Penaliza palabras comunes
• TF-IDF = TF × IDF: Resalta palabras importantes pero no comunes

Justificación de TF-IDF:

1. Eficaz para clasificación de texto con múltiples clases
2. Reduce peso de palabras comunes automáticamente
3. Sparse pero eficiente en memoria
4. Baseline sólido, estado del arte para muchos problemas NLP

Configuración utilizada:

TfidfVectorizer(
    ngram_range=(1, 2),      # Unigrams + Bigrams
    max_features=5000,       # Limitar dimensionalidad
    min_df=2,                # Ignorar términos muy raros
    max_df=0.95,             # Ignorar términos muy comunes
    sublinear_tf=True        # Escala logarítmica para TF
)

Justificación de n-gramas (1,2):

• Unigrams: Capturan palabras individuales importantes
• Bigrams: Capturan frases y contexto local
• Ejemplo: "machine learning" como bigrama es más informativo que las palabras separadas

Alternativas consideradas:

• ❌ Bag of Words: Más simple pero ignora importancia relativa
• ❌ Word2Vec/GloVe: Requieren más datos y tiempo de entrenamiento
• ❌ BERT/Transformers: Computacionalmente costoso para este problema

---

PASO 5: Análisis de PCA

Objetivo: Determinar si la reducción de dimensionalidad es beneficiosa

Criterios para aplicar PCA:

1. Alta dimensionalidad (5000+ features)
2. Features correlacionados
3. Necesidad de reducir overfitting
4. Visualización de datos

Desventajas de PCA para NLP con múltiples clases:

1. Pérdida de interpretabilidad: Componentes principales no son palabras
2. TF-IDF es sparse: PCA genera matrices densas (más memoria)
3. Puede perder información: Features raros pero discriminativos importantes para distinguir entre 16 clases

Decisión tomada:

if pca.n_components_ < X_train_tfidf.shape[1] * 0.3:
    # Usar PCA (reducción >70%)
else:
    # No usar PCA (mantener TF-IDF sparse)

Análisis realizado:

• Curva de varianza explicada acumulada
• Número de componentes necesarios para 95% varianza
• Comparación de eficiencia memoria: sparse vs dense

---

PASO 6: Entrenamiento de Modelos

Modelos seleccionados y justificación:

1. Logistic Regression

Pros:

• Rápido y eficiente
• Interpretable (coeficientes = importancia de palabras)
• Funciona bien con features sparse
• Baseline excelente para text classification

Hiperparámetros:

• C=1.0: Regularización L2 moderada
• class_weight='balanced': Maneja desbalance de clases
• solver='liblinear': Eficiente para datasets medianos

2. Multinomial Naive Bayes

Pros:

• Diseñado específicamente para datos de conteo (TF-IDF)
• Muy rápido, escala bien
• Funciona bien con poco datos
• Estado del arte clásico para text classification

Contras:

• Asume independencia de features (raramente cierto)

Hiperparámetros:

• alpha=0.1: Suavizado de Laplace (previene probabilidades cero)

3. Linear SVM (LinearSVC)

Pros:

• Encuentra hiperplano de máxima separación
• Robusto a overfitting con regularización adecuada
• Eficiente con datos high-dimensional sparse
• Excelente rendimiento en text classification

Hiperparámetros:

• C=1.0: Balance entre margen y error
• dual=False: Más eficiente cuando n_samples > n_features

4. Random Forest

Pros:

• Maneja relaciones no lineales
• Robusto a overfitting (averaging de múltiples árboles)
• Proporciona importancia de features
• No requiere normalización

Contras:

• Más lento con muchos features
• No optimizado para sparse matrices

Hiperparámetros:

• n_estimators=100: 100 árboles de decisión
• max_depth=None: Sin límite de profundidad
• min_samples_split=5: Control de overfitting

5. LightGBM

Pros:

• Estado del arte para muchos problemas
• Rápido y eficiente en memoria
• Maneja relaciones no lineales complejas
• Excelente con features categóricos

Contras:

• Requiere tuning cuidadoso
• Mayor riesgo de overfitting sin regularización adecuada

Hiperparámetros:

• n_estimators=100: Número de árboles
• max_depth=7: Profundidad máxima (control de overfitting)
• learning_rate=0.1: Tasa de aprendizaje

---

PASO 8: Validación Cruzada (Cross-Validation)

Configuración: 5-Fold Stratified Cross-Validation

¿Por qué Stratified con 16 clases?

• Mantiene las proporciones de las 16 clases en cada fold
• Crítico para problemas multi-clase
• Previene evaluación sesgada

Proceso:

1. Dividir datos de entrenamiento en 5 partes (folds)
2. Para cada fold:
   • Entrenar con 4 folds
   • Validar con 1 fold
3. Promediar resultados de los 5 folds

Ventajas:

• Uso eficiente de datos (todos los datos se usan para train y validation)
• Estimación robusta del rendimiento
• Reduce varianza de la evaluación
• Detecta overfitting: Si CV score << train score → overfitting

Métricas calculadas:

• Cross-validation mean ± std
• Training accuracy
• Validation accuracy
• F1-score, Precision, Recall (weighted para 16 clases)
• Diferencia train-val (indicador de overfitting)

Detección de Overfitting:

Si (train_accuracy - val_accuracy) > 0.15:
    → OVERFITTING SEVERO
Si (train_accuracy - val_accuracy) > 0.05:
    → OVERFITTING LEVE
Else:
    → SIN OVERFITTING SIGNIFICATIVO

---

PASO 9: Evaluación Final en Test Set

Métricas de evaluación para 16 clases:

1. Accuracy

• Definición: Porcentaje de predicciones correctas
• Fórmula: (TP + TN) / (TP + TN + FP + FN)
• Cuándo usar: Dataset balanceado

2. Precision

• Definición: De los predichos como clase X, cuántos son realmente X
• Fórmula: TP / (TP + FP)
• Interpretación: Mide "pureza" de predicciones positivas
• Importante cuando: Falsos positivos son costosos

3. Recall (Sensitivity)

• Definición: De todos los X reales, cuántos fueron detectados
• Fórmula: TP / (TP + FN)
• Interpretación: Mide "cobertura"
• Importante cuando: Falsos negativos son costosos

4. F1-Score

• Definición: Media armónica de Precision y Recall
• Fórmula: 2 × (Precision × Recall) / (Precision + Recall)
• Cuándo usar: Balance entre precision y recall, dataset desbalanceado

5. Confusion Matrix

• Visualiza errores de clasificación
• Diagonal: Predicciones correctas
• Fuera de diagonal: Confusiones entre clases
• Utilidad: Identificar qué clases se confunden entre sí

Visualizaciones generadas:

• Matriz de confusión (valores absolutos)
• Matriz de confusión normalizada (porcentajes)
• Gráficos comparativos de métricas por modelo

---

PASO 10: Análisis de Errores

Objetivo: Entender dónde y por qué falla el modelo

Análisis realizado:

1. Identificación de casos mal clasificados
2. Examen de texto original de errores
3. Identificación de pares de clases más confundidos
4. Análisis de patrones en errores

Utilidad:

• Identificar limitaciones del modelo
• Detectar problemas de calidad de datos (OCR errors)
• Decidir si necesitamos más datos de ciertas clases
• Guiar mejoras futuras del sistema

---

PASO 11: Deployment del Modelo

Archivos generados:

1. model_latest.pkl: Mejor modelo entrenado (serializado)
2. vectorizer_latest.pkl: Vectorizador TF-IDF (preserva vocabulario)
3. metadata_latest.json: Metadatos (accuracy, fecha, configuración)

Función de predicción:

result = predict_document_class(
    image_path="documento_nuevo.png",
    model=best_model,
    vectorizer=tfidf_vectorizer,
    class_labels_dict=class_labels,
    preprocess_func=preprocess_data
)

print(f"Clase predicha: {result['predicted_class']}")
print(f"Confianza: {result['confidence']*100:.2f}%")

Pipeline de predicción:

1. Cargar imagen
2. OCR con Tesseract
3. Preprocesar texto
4. Vectorizar con TF-IDF
5. Predecir con modelo
6. Retornar clase + probabilidades

---

📈 Resultados Esperados

Métricas Objetivo (basadas en literatura)

• Accuracy: > 85% en test set
• F1-Score: > 0.80 en todas las clases
• Overfitting: < 0.05 diferencia train-val

Comparación de Modelos

Modelo                 CV Accuracy    Val Accuracy   F1-Score   Overfitting
────────────────────────────────────────────────────────────────────────────
Logistic Regression    0.8850±0.022   0.8900         0.8850     +0.0120
Linear SVM             0.8920±0.018   0.8980         0.8920     +0.0100
Naive Bayes            0.8650±0.031   0.8700         0.8600     +0.0180
Random Forest          0.8750±0.025   0.8650         0.8620     +0.0450
LightGBM               0.8980±0.020   0.8850         0.8800     +0.0380

(Nota: Valores reales dependerán del dataset específico)

---

🔧 Uso del Sistema

1. Cargar y Procesar Dataset

# Definir clases
class_labels = {
    'email': 0,
    'resume': 1,
    'scientific_publication': 2
}

# Cargar dataset
df = load_documents_from_images(
    dataset_path=r"datasets\document-classification-dataset",
    class_labels_dict=class_labels
)

2. Entrenar Modelo

# Dividir datos
X_train, X_val, X_test, y_train, y_val, y_test = split_dataset_stratified(
    df, train_size=0.7, val_size=0.2, test_size=0.1
)

# Crear features TF-IDF
X_train_tfidf, X_val_tfidf, X_test_tfidf, vectorizer = create_tfidf_features(
    X_train, X_val, X_test
)

# Entrenar modelos
model_results, best_model_name = train_and_evaluate_models(
    X_train_tfidf, X_val_tfidf, y_train, y_val
)

# Evaluar en test
best_model = model_results[best_model_name]['model']
test_results = evaluate_on_test_set(best_model, X_test_tfidf, y_test)

3. Guardar Modelo

save_model_artifacts(
    model=best_model,
    vectorizer=vectorizer,
    class_labels_dict=class_labels,
    model_name=best_model_name,
    test_results=test_results
)

4. Usar Modelo para Predicción

# Cargar modelo guardado
import pickle

with open('models/model_latest.pkl', 'rb') as f:
    model = pickle.load(f)

with open('models/vectorizer_latest.pkl', 'rb') as f:
    vectorizer = pickle.load(f)

# Predecir documento nuevo
result = predict_document_class(
    image_path="nuevo_documento.png",
    model=model,
    vectorizer=vectorizer,
    class_labels_dict=class_labels,
    preprocess_func=preprocess_data
)

print(f"Resultado: {result['predicted_class']}")
print(f"Confianza: {result['confidence']*100:.2f}%")

---

📊 Visualizaciones Incluidas

1. Análisis Exploratorio

• Distribución de clases (barras y pastel)
• Distribución de longitud de texto (boxplot, histograma, violin)
• Word clouds por clase
• Tabla de estadísticas por clase

2. Análisis de Modelos

• Comparación de accuracy por modelo
• Cross-validation con intervalos de confianza
• Comparación de F1-scores
• Análisis de overfitting por modelo

3. Evaluación de Test

• Matriz de confusión (absoluta y normalizada)
• Métricas por clase
• Curva de varianza explicada (si se usa PCA)

---

🎓 Criterios de Evaluación Cumplidos

1. Selección de Features ✅

Criterio: Justificar elección de representación

Respuesta:

• TF-IDF seleccionado por ser estado del arte para text classification
• N-gramas (1,2) para capturar contexto local y frases específicas
• Sparse matrices para eficiencia de memoria
• Alternativas evaluadas: BoW, Word2Vec, BERT (justificado por qué no se usaron)

2. Selección de Algoritmos ✅

Criterio: Justificar elección de algoritmos

Respuesta:

• 5 algoritmos evaluados: desde baseline simple (Naive Bayes) hasta ensemble avanzado (LightGBM)
• Justificación individual de cada modelo: pros, contras, cuándo usarlo
• Configuración de hiperparámetros explicada y justificada
• Comparación objetiva mediante cross-validation

3. Análisis Exploratorio Exhaustivo ✅

Criterio: EDA completo y profundo

Respuesta:

• Balance de clases con análisis de desbalance y recomendaciones
• Distribución de longitud con múltiples visualizaciones
• Análisis de vocabulario con word clouds y frecuencias
• Detección de problemas de calidad de datos
• Visualizaciones múltiples para cada aspecto

4. Argumentación de Decisiones ✅

Criterio: Justificar cada decisión importante

Respuesta:

• Preprocesamiento: Cada paso explicado (por qué lemmatization y no stemming)
• TF-IDF: Justificación de configuración (n-grams, max_features, etc.)
• PCA: Análisis completo de necesidad con criterios objetivos
• Modelos: Justificación de hiperparámetros
• División de datos: Justificación de 70-20-10

5. Aplicación de PCA ✅

Criterio: Evaluar si PCA es necesario

Respuesta:

• Análisis completo de dimensionalidad actual
• Evaluación de trade-offs: interpretabilidad vs reducción
• Curva de varianza para decisión informada
• Decisión fundamentada: Usar PCA solo si reducción > 70%
• Justificación de no usar: TF-IDF sparse es más eficiente

6. Verificación de Overfitting ✅

Criterio: Cross-validation para detectar overfitting

Respuesta:

• 5-fold stratified CV en todos los modelos
• Métricas train vs val comparadas sistemáticamente
• Umbrales definidos: 0.05 (leve), 0.10 (severo)
• Visualización de overfitting por modelo
• Recomendaciones si se detecta overfitting

---

🚀 Mejoras Futuras

Corto Plazo

1. Mejorar calidad de OCR:

   • Preprocesamiento de imágenes (binarización, deskew, denoising)
   • Usar Tesseract 5.x con LSTM
   • Detectar orientación automáticamente

2. Feature Engineering adicional:

   • Features de layout (posición de texto, formato)
   • Ratio de texto vs espacio en blanco
   • Presencia de logos, firmas, imágenes

3. Aumentar dataset:

   • Más ejemplos de cada clase
   • Diversidad de layouts y formatos
   • Documentos de diferentes fuentes

Medio Plazo

1. Modelos más avanzados:

   • Transfer learning con BERT/RoBERTa
   • Multimodal (texto + imagen)
   • Ensemble stacking de múltiples modelos

2. Deployment en producción:

   • API REST con Flask/FastAPI
   • Dockerización del sistema
   • Monitoreo de performance

3. Más clases:

   • Facturas, contratos, formularios
   • Dataset extendido con 15+ categorías

Largo Plazo

1. Procesamiento de documentos complejos:

   • PDFs con múltiples páginas
   • Documentos escaneados de baja calidad
   • Idiomas múltiples

2. Análisis semántico profundo:

   • Extracción de entidades (NER)
   • Relaciones entre documentos
   • Resumen automático

---

📚 Referencias

Papers y Literatura

1. Ramos, J. (2003). "Using TF-IDF to Determine Word Relevance in Document Queries"
2. Sebastiani, F. (2002). "Machine Learning in Automated Text Categorization"
3. Bird, S., Klein, E., & Loper, E. (2009). "Natural Language Processing with Python"

Documentación Técnica

• scikit-learn Documentation
• NLTK Documentation
• Tesseract OCR Documentation

Datasets

• Document Classification Dataset (Kaggle)

---

👤 Autor

LEONI
Maestría en IoT y AI
Materia: Inteligencia Artificial
Noviembre 2025

---

📄 Licencia

Este proyecto es parte de un trabajo académico para la Maestría en IoT y AI.

---

🤝 Contribuciones

Este es un proyecto académico, pero sugerencias y feedback son bienvenidos.

---

⚠️ Notas Importantes

Limitaciones Conocidas

1. Dependencia de calidad de OCR: Imágenes de baja calidad producen texto incorrecto
2. Idioma: Sistema entrenado para inglés
3. Layouts específicos: Mejor rendimiento con layouts estándar
4. Tamaño de dataset: Rendimiento mejorará con más datos

Requisitos de Hardware

• Mínimo: 8GB RAM, procesador dual-core
• Recomendado: 16GB RAM, procesador quad-core, SSD
• Para GPU: CUDA-compatible GPU (opcional, para modelos deep learning futuros)

Tiempo de Ejecución Estimado

• Carga de dataset (~150 imágenes): 5-10 minutos
• Training de todos los modelos: 10-20 minutos
• EDA completo: 5 minutos
• Total: ~30-40 minutos

---

📞 Soporte

Para preguntas o problemas:

1. Revisar la documentación en este README
2. Verificar que todas las dependencias estén instaladas
3. Asegurarse de que Tesseract esté correctamente configurado
4. Revisar los comentarios en el código del notebook

---

¡Gracias por usar este sistema de clasificación de documentos! 🎉