UranoCon es un modelo de IA experimental basado en arquitectura transformer moderna con características avanzadas y técnicas de vanguardia. Nuestra dirección es basarnos en un modelo interno llamado seed (semilla) - un modelo con limitaciones de entendimiento pero mucho más centrado en la eficacia de sus respuestas y relaciones, dando como resultado un modelo más específico para ciertas tareas.

• Entrenamiento secuencial: Procesa múltiples carpetas de datos de forma progresiva
• Preservación de conocimiento: Cada ciclo mejora el modelo anterior sin perder aprendizajes
• Múltiples formatos: Soporte automático para PDF, DOCX y TXT
• Quantización inteligente: Compresión de modelos hasta 98.5% de reducción

• PDF: Extracción inteligente con PyPDF2 y pdfplumber
• DOCX: Procesamiento completo de documentos Word
• TXT: Soporte nativo con múltiples encodings
• Detección automática: El sistema identifica y procesa todos los formatos disponibles

• Análisis morfológico: Género, número, conjugaciones verbales
• Sintaxis avanzada: Estructuras Sujeto-Verbo-Predicado, interrogativas
• Semántica contextual: Grupos semánticos, sinónimos, relaciones
• Patrones fonéticos: Sílabas, diptongos, combinaciones consonánticas

• Weighted Fine-Tuning: Pesos adaptativos por capa
• Pattern Search Regularizer: Búsqueda y refuerzo de patrones similares
• Multi-Weight Attention Bias: Relaciones semánticas como bias de atención
• Continuous Fine-Tuning: Reentrenamiento continuo basado en rendimiento

• RMSNorm: Normalización más eficiente que LayerNorm
• SwiGLU: Activación moderna que reemplaza ReLU
• Multi-Head Attention: Con optimizaciones y sin bias
• Flash Attention: Optimización de memoria nativa de PyTorch 2.0+
• Grouped Query Attention (GQA): Reducción de parámetros KV
• Sliding Window Attention: Atención local para secuencias largas

• Gradient Clipping: Para estabilizar el entrenamiento
• AdamW Optimizer: Con weight decay para mejor regularización
• Cosine Annealing Scheduler: Con warmup y decay automático
• CrossEntropy con ignore_index: Para manejar padding tokens

• KV Cache: Generación eficiente sin recalcular atención
• Top-k Sampling: Filtrado por los k tokens más probables
• Top-p (Nucleus) Sampling: Filtrado por probabilidad acumulada
• Beam Search: Búsqueda de haz para generación más inteligente
• Repetition Penalty: Evita repeticiones excesivas
• Temperature Control: Control fino de la creatividad

• Detector en Tiempo Real: Monitoreo continuo de overfitting durante entrenamiento
• Correcciones Automáticas: Ajuste de learning rate y dropout automático
• Early Stopping Inteligente: Parada temprana con múltiples métricas
• Diversidad de Vocabulario: Control de repeticiones y colapso del modelo

• Dynamic Quantization: Compresión INT8 post-entrenamiento
• Post-Training Quantization: Con calibración para máxima precisión
• Modelos Compactos: Reducción de hasta 98.5% del tamaño
• Preservación de Calidad: Mínima pérdida de rendimiento

• LoRA (Low-Rank Adaptation): Fine-tuning con pocos parámetros
• Adaptación Selectiva: Aplicar LoRA solo a capas específicas
• Fusión de Pesos: Integrar adaptaciones al modelo base
• Fine-Tuning Continuo: Reentrenamiento adaptativo por capas

• CLI Completo: Entrenamiento, generación, guardado/carga por comandos
• Guardado Seguro: Usa Safetensors para almacenamiento seguro y eficiente
• Arquitectura Modular: Patrón de manejadores extensible
• Logging Avanzado: Seguimiento detallado del entrenamiento

• PyTorch 2.1.0+
• NumPy 1.24.3
• Safetensors 0.4.0+
• tqdm 4.66.1
• typing_extensions 4.12.2+

• Para PDF: PyPDF2>=3.0.0, pdfplumber>=0.9.0
• Para DOCX: python-docx>=0.8.11
• Para crear PDFs: reportlab>=4.0.0

# Dependencias básicas
pip install -r requirements.txt

# Instalar dependencias básicas
pip install -r requirements.txt

# Soporte completo para múltiples formatos
py -m pip install PyPDF2 pdfplumber python-docx

# Opcional: Para crear PDFs de ejemplo
py -m pip install reportlab

# Entrenamiento progresivo básico (RECOMENDADO)
python main.py progresivo --directorio datos_entrenamiento

# Con configuración personalizada
python main.py progresivo --directorio datos_entrenamiento --epochs-ciclo 10 --batch-size 8

# Con quantización y fine-tuning avanzado
python main.py progresivo --directorio datos_entrenamiento --quantization --weighted-fine-tuning

# Continuar desde modelo base
python main.py progresivo --directorio datos_entrenamiento --modelo-base modelos/progresivo_final

📁 Estructura de Directorios para Entrenamiento Progresivo:

datos_entrenamiento/
├── ciclo_1/          # Vocabulario base
│   ├── base.txt
│   └── fundamentos.pdf
├── ciclo_2/          # Conversaciones
│   ├── dialogos.txt
│   └── conversaciones.docx
├── ciclo_3/          # Textos avanzados
│   ├── literatura.txt
│   └── articulos.pdf
└── nuevos/           # Contenido adicional
    ├── documentos.pdf
    └── textos.docx

# Entrenamiento con fine-tuning avanzado
python main.py avanzado-experimental-fine-tuning --file texto.txt

# Con quantización y sistemas avanzados
python main.py avanzado-experimental-fine-tuning --file texto.txt --quantization --quantization-type dynamic

# Con pattern search y multi-weight attention
python main.py avanzado-experimental-fine-tuning --file texto.txt --pattern-weight 0.05 --relation-weight 0.02

# Entrenamiento experimental con análisis lingüístico
python main.py experimental --texto "hola mundo" --epochs 20

# Entrenamiento avanzado con análisis completo del español
python main.py avanzado-experimental --file texto.txt --epochs 30

# Entrenamiento con Flash Attention y ventana deslizante
python main.py train --texto "ejemplo" --epochs 15 --use-flash-attention --window-size 16

# Entrenamiento con GQA (Grouped Query Attention)
python main.py train --texto "ejemplo" --epochs 15 --use-gqa --num-kv-heads 2

# Generación básica con KV cache
python main.py generate --prompt "hola" --load modelos/llm_simple.pth

# Generación con temperatura alta (más creativa)
python main.py generate --prompt "el gato" --temperature 1.2 --max-length 30

# Generación con top-k y top-p
python main.py generate --prompt "la luna" --top-k 20 --top-p 0.8

# Beam search para mejor calidad
python main.py generate --prompt "el sol" --beam-size 5 --max-length 25

# Generación conservadora
python main.py generate --prompt "buenos días" --temperature 0.5 --top-k 10

# Generación sin KV cache (más lenta pero más precisa)
python main.py generate --prompt "ejemplo" --use-kv-cache false

# En tu script Python
from urano_con.patterns import ManejadorPatronLLM

llm_handler = ManejadorPatronLLM(main_handler)

# Aplicar LoRA
lora_manager = llm_handler.aplicar_lora(rank=8, alpha=16, target_modules="attention")

# Fine-tuning
textos_especializados = ["texto específico 1", "texto específico 2"]
resultado = llm_handler.fine_tune_lora(textos_especializados, epochs=3, lr=5e-4)

# Fusionar LoRA
llm_handler.fusionar_lora()

# Estado del sistema
python main.py status

# Ejemplo completo con todas las técnicas
python main.py example

Características principales:

• Preservación de entrenamiento: Cuando el vocabulario se expande, el sistema transfiere automáticamente los pesos del modelo anterior al nuevo, preservando el conocimiento aprendido
• Entrenamiento incremental: Cada nuevo texto se agrega al entrenamiento existente sin perder el progreso previo
• Carga de modelos preentrenados: Puedes continuar entrenando desde un modelo guardado previamente

Características principales:

• Tokenización de caracteres: Entrena el modelo con caracteres individuales en lugar de palabras
• Generación de patrones: Aprende patrones a nivel de caracteres para generar texto
• Modelo optimizado: Arquitectura más pequeña optimizada para caracteres
• Experimentos creativos: Permite experimentar con generación basada en letras

# Entrenamiento experimental básico
python main.py experimental

# Con textos personalizados
python main.py experimental --texto "hola mundo" --texto "python es genial"

# Con archivo de textos
python main.py experimental --file mis_textos.txt --epochs 30

# Con parámetros personalizados
python main.py experimental --batch-size 32 --warmup-steps 100

# Continuar desde modelo preentrenado
python main.py experimental --modelo modelos/experimental_anterior

Ejemplo de salida experimental:

[EXPERIMENTAL] Iniciando entrenamiento experimental con tokenización de caracteres
[EXPERIMENTAL] Textos de entrada: ['hola mundo', 'python es genial', ...]
[EXPERIMENTAL] Tokenizador de caracteres inicializado
[EXPERIMENTAL] Vocabulario de caracteres construido: 45 caracteres
[EXPERIMENTAL] Caracteres: ['<PAD>', '<UNK>', '<START>', '<END>', 'a', 'b', 'c', ...]
[EXPERIMENTAL] Modelo de caracteres creado
[EXPERIMENTAL] Iniciando entrenamiento: 20 épocas, batch_size=16

[EXPERIMENTAL] Época 1/20, Batch 0/15, Loss: 2.3456
[EXPERIMENTAL] Época 1 completada - Loss promedio: 2.1234

[EXPERIMENTAL] Prueba con 'a': ahola mundo python es genial
[EXPERIMENTAL] Prueba con 'e': es genial python mundo hola
[EXPERIMENTAL] Prueba con 'h': hola mundo python es genial

[EXPERIMENTAL] Entrenamiento experimental completado!
[EXPERIMENTAL] Modelo guardado en: modelos/experimental_caracteres
[EXPERIMENTAL] Loss promedio total: 1.2345

[EXPERIMENTAL] Pruebas finales de generación:
[EXPERIMENTAL] 'a' -> ahola mundo python es genial
[EXPERIMENTAL] 'e' -> es genial python mundo hola
[EXPERIMENTAL] 'h' -> hola mundo python es genial
[EXPERIMENTAL] 'm' -> mundo hola python es genial
[EXPERIMENTAL] 'p' -> python es genial mundo hola

# Entrenamiento interactivo básico
python main.py interactive

# Con textos iniciales adicionales
python main.py interactive --texto "mi texto personalizado" --texto "otro texto"

# Con archivo de textos iniciales
python main.py interactive --file mis_textos.txt --epochs 10

# Con parámetros personalizados
python main.py interactive --batch-size 4 --warmup-steps 50

# Continuar entrenamiento desde un modelo preentrenado
python main.py interactive --modelo modelos/mi_modelo_anterior

Comandos disponibles durante el entrenamiento interactivo:

• Texto libre: Escribe cualquier texto para agregarlo al entrenamiento
• test <prompt>: Probar generación (ej: test el gato)
• status: Ver estadísticas del entrenamiento
• save <ruta>: Guardar modelo (ej: save modelos/mi_modelo)
• quit o exit: Finalizar y guardar automáticamente
• help: Mostrar ayuda
• Ctrl+C: Interrumpir y guardar

Ejemplo de sesión interactiva:

============================================================
[INTERACTIVO] ENTRENAMIENTO INTERACTIVO ACTIVO
============================================================
Comandos disponibles:
  - Escribe cualquier texto para agregarlo al entrenamiento
  - 'test <prompt>' - Probar generación (ej: 'test el gato')
  - 'status' - Ver estadísticas del entrenamiento
  - 'save <ruta>' - Guardar modelo (ej: 'save modelos/mi_modelo')
  - 'quit' o 'exit' - Finalizar y guardar
  - 'help' - Mostrar esta ayuda
============================================================

[INPUT] Ingresa texto o comando: el robot inteligente aprende rápido

[ENTRENANDO] Agregando texto al entrenamiento: 'el robot inteligente aprende rápido'
[VOCAB] Vocabulario actualizado: 30 tokens
[MODELO] Vocabulario expandido, aplicando LoRA para preservar entrenamiento...
[MODELO] Transferencia de pesos completada - entrenamiento previo preservado
[COMPLETADO] Entrenamiento completado - Época 6, Loss: 0.8234
[AUTO-TEST] Prueba automática con 'el robot': el robot inteligente aprende rápido y eficientemente

[INPUT] Ingresa texto o comando: test el robot
[TEST] Probando generación con: 'el robot'
[RESULTADO] Resultado: el robot inteligente aprende rápido y eficientemente

[INPUT] Ingresa texto o comando: status
[STATUS] ESTADÍSTICAS:
  - Textos entrenados: 6
  - Épocas totales: 6
  - Vocabulario: 30 tokens
  - Dispositivo: cpu

[INPUT] Ingresa texto o comando: quit
[GUARDANDO] Guardando modelo y finalizando...

# Ejecutar ejemplo interactivo
python ejemplo_interactivo.py

RMSNorm:

• Normalización basada en RMS (Root Mean Square)
• Más eficiente computacionalmente que LayerNorm
• Mejor estabilidad en entrenamiento

SwiGLU:

• Activación Swish-Gated Linear Unit
• Mejor rendimiento que ReLU en transformers
• Gating mechanism para mejor control de flujo

Flash Attention:

• Optimización de memoria nativa de PyTorch 2.0+
• Reduce uso de memoria en atención
• Mejor rendimiento en GPUs modernas

Grouped Query Attention (GQA):

• Reduce parámetros KV manteniendo calidad
• Configurable con num_kv_heads
• Eficiencia en modelos grandes

Sliding Window Attention:

• Atención local para secuencias largas
• Configurable con window_size
• Escalabilidad a textos muy largos

KV Cache:

• Cache de keys y values para generación eficiente
• Evita recalcular atención en tokens previos
• Acelera generación significativamente

LoRA (Low-Rank Adaptation):

• Fine-tuning eficiente con pocos parámetros
• Adaptación de rango bajo a capas lineales
• Permite especialización sin reentrenar todo el modelo

Modelo Progresivo (Recomendado):

• d_model: 128 dimensiones (optimizado para eficiencia)
• num_heads: 4 cabezas de atención (balanceado)
• num_layers: 3 bloques transformer (efectivo sin overfitting)
• d_ff: 512 dimensiones feed-forward (previene memorización)
• dropout: 0.4 (anti-overfitting agresivo)
• seq_length: 16 (aprendizaje gradual)
• learning_rate: 0.0005 (optimizado para modelo pequeño)
• weight_decay: 0.01 (regularización moderada)

Sistemas Avanzados Habilitados:

• use_flash_attention: True
• pattern_search: True (peso: 0.05)
• multi_weight_attention: True (peso: 0.02)
• spanish_language_constructor: True
• anti_overfitting_detector: True
• quantization: True (Dynamic INT8)

• main.py: CLI completo con todos los comandos
• urano_con/main_handler.py: Orquestador principal del sistema
• urano_con/patterns/llm_handler.py: LLM transformer con técnicas avanzadas

• urano_con/patterns/spanish_constructor.py: Constructor del Lenguaje Español
• urano_con/patterns/overfitting_detector.py: Detector Anti-Overfitting
• urano_con/patterns/quantization.py: Sistema de Quantización
• urano_con/patterns/pattern_systems.py: Pattern Search y Multi-Weight Attention
• urano_con/patterns/fine_tuning.py: Sistemas de Fine-Tuning Avanzado

• urano_con/utils/document_processor.py: Procesador Multi-Formato
• urano_con/utils/constants.py: Constantes del sistema

• datos_entrenamiento/: Carpetas organizadas por ciclos
• modelos/: Modelos entrenados y quantizados
• requirements.txt: Dependencias del proyecto

• Metodología: Entrenamiento secuencial con preservación de conocimiento
• Ventajas: Evita olvido catastrófico, permite especialización gradual
• Implementación: Cada ciclo mejora el modelo anterior sin pérdida de información

• Análisis Morfológico: Reglas de género, número, conjugaciones verbales
• Análisis Sintáctico: Estructuras SVO, interrogativas, conectores
• Análisis Semántico: Grupos temáticos, sinónimos, relaciones contextuales
• Análisis Fonético: Patrones silábicos, diptongos, combinaciones consonánticas

• Detección en Tiempo Real: Monitoreo de loss, diversidad de vocabulario, patrones
• Correcciones Automáticas: Ajuste dinámico de learning rate y dropout
• Early Stopping Inteligente: Múltiples métricas para decisión de parada
• Modo Emergencia: Activación automática ante colapso del modelo

• Weighted Fine-Tuning: Pesos adaptativos por capa según rendimiento
• Pattern Search: Búsqueda activa y refuerzo de patrones similares
• Multi-Weight Attention: Bias semántico en mecanismo de atención
• Continuous Fine-Tuning: Reentrenamiento continuo basado en métricas

• Dynamic Quantization: INT8 post-entrenamiento para compresión
• Preservación de Calidad: Mínima pérdida de rendimiento
• Modelos Compactos: Hasta 98.5% de reducción de tamaño

• 🎯 Efectividad: Parámetros optimizados para máximo rendimiento
• ⚡ Eficiencia: Modelos compactos sin pérdida de calidad
• 🛡️ Robustez: Sistema anti-overfitting que previene colapso
• 📄 Versatilidad: Soporte automático para PDF, DOCX, TXT
• 🔄 Escalabilidad: Entrenamiento progresivo permite crecimiento continuo

• Guardado: Modelos en 3 archivos (.tokenizer.json, .model, .config.json)
• Quantización: Modelos quantizados guardados por separado para preservar gradientes
• Multi-Formato: Detección automática de formatos disponibles
• Compatible: Windows, Linux, macOS con Python 3.8+
• GPU Opcional: Funciona en CPU, optimizado para GPU si está disponible

# 1. Instalar dependencias completas
pip install -r requirements.txt
py -m pip install PyPDF2 pdfplumber python-docx

# 2. Crear estructura de datos
mkdir -p datos_entrenamiento/ciclo_1 datos_entrenamiento/nuevos

# 3. Agregar archivos de texto/PDF/DOCX a las carpetas

# 4. Entrenar modelo progresivo
python main.py progresivo --directorio datos_entrenamiento

# 5. Probar generación
python main.py generate --prompt "hola mundo" --load modelos/progresivo_final