Plataforma Educativa Interactiva para Optimización No Lineal
Una aplicación web moderna que analiza, resuelve y explica problemas de optimización no lineal de forma interactiva, con asistente de IA integrado.
- 🎯 Descripción
- ✨ Características
- 🛠️ Métodos Soportados
- 🏗️ Arquitectura
- 📦 Requisitos
- 🚀 Instalación
- ⚙️ Configuración
- 🎮 Uso
- 📁 Estructura del Proyecto
- 🤖 Sistema de Detección Inteligente
- 🔧 API Reference
- 📊 Visualizaciones
- 🧪 Testing
- 🤝 Contribución
- 📄 Licencia
OptiLearn Web es una plataforma educativa basada en Django diseñada para estudiantes y profesionales que desean aprender y resolver problemas de Programación No Lineal (PNL).
La aplicación combina:
- 🧮 Cálculo simbólico con SymPy
- 📈 Cálculo numérico con NumPy/SciPy
- 📊 Visualización interactiva 2D/3D con Plotly y Matplotlib
- 💬 Asistente de IA educativo con Groq (LLaMA)
- 📄 Generación de reportes académicos en PDF
El objetivo principal es enseñar optimización, no solo resolverla. Cada solución incluye:
- Pasos matemáticos detallados
- Explicaciones en lenguaje natural
- Visualizaciones del proceso de convergencia
- Interpretación de resultados
| Modo Manual | Modo Asistente IA |
|---|---|
| Formularios estructurados por método | Chat en lenguaje natural |
| Control total de parámetros | Detección automática del método |
| Resultados inmediatos | Explicaciones pedagógicas |
| Ideal para práctica | Ideal para aprendizaje |
- ✅ Análisis automático de problemas (variables, restricciones, convexidad)
- ✅ Recomendación inteligente del método óptimo
- ✅ Resolución paso a paso con explicaciones detalladas
- ✅ Visualización 2D/3D de funciones y trayectorias
- ✅ Chat educativo con historial por sesión
- ✅ Exportación PDF con gráficas y desarrollo completo
- ✅ Renderizado LaTeX para fórmulas matemáticas
- ✅ Tiempo real via WebSockets (Django Channels)
OptiLearn implementa 5 métodos de optimización cubriendo los casos más comunes de PNL:
Minimizar/Maximizar f(x)
- Calcula gradiente y Hessiano
- Encuentra puntos críticos (∇f = 0)
- Clasifica puntos usando criterio de la segunda derivada
- Determina máximos, mínimos y puntos silla
Minimizar f(x)
sujeto a: g(x) = 0
- Construye la función Lagrangiana L(x, λ)
- Resuelve sistema de ecuaciones estacionarias
- Clasifica puntos usando Hessiano orlado
- Visualización de curvas de nivel
Minimizar f(x)
sujeto a: g(x) = 0, h(x) ≤ 0
- Aplica condiciones de Karush-Kuhn-Tucker
- Verifica factibilidad primal y dual
- Analiza complementariedad (μ·h(x) = 0)
- Soporta múltiples restricciones
x_{k+1} = x_k - α·∇f(x_k)
- Búsqueda de línea (Armijo backtracking)
- Visualización de trayectoria de convergencia
- Métricas por iteración (norma del gradiente, paso)
- Criterios de parada configurables
Minimizar ½x'Qx + c'x
sujeto a: Ax ≤ b, A_eq·x = b_eq
- Análisis de convexidad (eigenvalores de Q)
- Múltiples solvers: KKT simbólico, numérico, simplex
- Descomposición de la matriz Q
- Verificación de optimalidad
┌─────────────────────────────────────────────────────────────────┐
│ FRONTEND │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │
│ │ Chat IA │ │ Forms │ │ Visualizaciones │ │
│ │ (WebSocket)│ │ (REST API) │ │ (Plotly/Matplotlib) │ │
│ └──────┬──────┘ └──────┬──────┘ └────────────┬────────────┘ │
└─────────┼────────────────┼──────────────────────┼───────────────┘
│ │ │
▼ ▼ ▼
┌─────────────────────────────────────────────────────────────────┐
│ DJANGO BACKEND │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ API Layer │ │
│ │ • REST Framework (views.py) │ │
│ │ • WebSocket Consumers (consumers.py) │ │
│ └──────────────────────────┬──────────────────────────────┘ │
│ │ │
│ ┌──────────────────────────┼──────────────────────────────┐ │
│ │ CORE MODULES │ │
│ │ ┌──────────────┐ ┌─────┴──────┐ ┌─────────────────┐ │ │
│ │ │ analyzer.py │ │ method_ │ │ recommender_ │ │ │
│ │ │ (Parse/Eval) │ │ detector │ │ ai.py │ │ │
│ │ └──────────────┘ └────────────┘ └─────────────────┘ │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ SOLVERS │ │ │
│ │ │ • solver_differential.py │ │ │
│ │ │ • solver_lagrange.py │ │ │
│ │ │ • solver_kkt.py │ │ │
│ │ │ • solver_gradiente.py │ │ │
│ │ │ • solver_qp_*.py │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────┐ │ │
│ │ │ VISUALIZERS │ │ │
│ │ │ • visualizer_lagrange.py / _3d.py │ │ │
│ │ │ • visualizer_differential.py / _3d.py │ │ │
│ │ └─────────────────────────────────────────────────┘ │ │
│ └──────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────────┐ │
│ │ AI SERVICE │ │
│ │ • groq_service.py (LLaMA via Groq API) │ │
│ │ • Prompts contextuales educativos │ │
│ │ • Scope guard (limita a temas de PNL) │ │
│ └──────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────┐
│ DATA LAYER │
│ ┌────────────┐ ┌────────────┐ ┌────────────────────────┐ │
│ │ SQLite │ │ Static │ │ Temporary Files │ │
│ │ (DB) │ │ Files │ │ (Plots PNG/SVG) │ │
│ └────────────┘ └────────────┘ └────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
| Capa | Tecnología |
|---|---|
| Backend | Django 5.x, Django REST Framework, Django Channels |
| IA | Groq API (LLaMA 3), prompts personalizados |
| Cálculo | SymPy (simbólico), NumPy/SciPy (numérico) |
| Visualización | Plotly (3D interactivo), Matplotlib (2D estático) |
| Frontend | Bootstrap 5, JavaScript vanilla, MathJax (LaTeX) |
| BD | SQLite (desarrollo), PostgreSQL (producción) |
| WebSocket | Django Channels (ASGI) |
- Python 3.11 o superior
- pip (gestor de paquetes)
- Git
Django>=4.2
djangorestframework>=3.15
channels>=4.0
sympy>=1.12
numpy>=1.26
python-dotenv>=1.0
groq>=0.10.0
# Opcionales
plotly>=5.24
matplotlib>=3.9
scipy>=1.11
reportlab>=4.2git clone https://github.com/DAMT777/Programacion_No_Lineal.git
cd Programacion_No_LinealWindows (PowerShell):
python -m venv .venv
.\.venv\Scripts\Activate.ps1Linux/macOS:
python -m venv .venv
source .venv/bin/activatepip install -r requirements.txtCrear archivo .env en opti_learn/:
# Django
DJANGO_SECRET_KEY=tu-clave-secreta-aqui
DEBUG=1
ALLOWED_HOSTS=127.0.0.1,localhost
# Groq API (para asistente IA)
GROQ_API_KEY=gsk_tu_api_key_aqui💡 Obtener API Key de Groq: Visita console.groq.com para obtener tu API key gratuita.
cd opti_learn
python manage.py migratepython manage.py collectstatic --noinputpython manage.py runserverAbre tu navegador en: http://127.0.0.1:8000
| Variable | Descripción | Default |
|---|---|---|
DJANGO_SECRET_KEY |
Clave secreta de Django | dev-insecure-secret-key |
DEBUG |
Modo debug | 1 |
ALLOWED_HOSTS |
Hosts permitidos | 127.0.0.1,localhost |
GROQ_API_KEY |
API Key de Groq | - |
DATABASE_URL |
URL de base de datos | SQLite |
En settings.py:
AI_ASSISTANT = {
"prompt_path": "opti_app/ai/prompt_contextual.txt",
"model": "llama-3.3-70b-versatile",
"temperature": 0.5,
"max_tokens": 2048,
}- Selecciona un método en la barra lateral
- Ingresa la función objetivo
- Define variables y restricciones (si aplica)
- Configura parámetros (tolerancia, iteraciones, etc.)
- Presiona "Resolver"
Ejemplo - Lagrange:
Función objetivo: x^2 + y^2
Restricción: x + y - 1 = 0
Escribe tu problema en lenguaje natural:
"Minimiza x² + y² sujeto a x + y = 1"
"Encuentra los puntos críticos de f(x,y) = x³ - 3xy + y³"
"Resuelve el problema QP: min ½(x² + y²) + 2x + 3y con x ≥ 0, y ≥ 0"
El asistente:
- Detecta automáticamente el método apropiado
- Resuelve paso a paso
- Genera visualizaciones
- Explica los resultados
Proyecto_PNL/
├── 📄 README.md # Este archivo
├── 📄 requirements.txt # Dependencias Python
├── 📄 .gitignore # Archivos ignorados por Git
│
└── 📁 opti_learn/ # Proyecto Django
├── 📄 manage.py # CLI de Django
├── 📄 .env # Variables de entorno (no versionado)
│
├── 📁 opti_learn/ # Configuración del proyecto
│ ├── settings.py # Configuración Django
│ ├── urls.py # URLs principales
│ ├── asgi.py # ASGI (WebSockets)
│ └── wsgi.py # WSGI (HTTP)
│
├── 📁 opti_app/ # Aplicación principal
│ ├── 📄 models.py # Modelos de datos
│ ├── 📄 views.py # Vistas y API endpoints
│ ├── 📄 urls.py # Rutas de la app
│ ├── 📄 consumers_ai.py # WebSocket consumers
│ ├── 📄 routing.py # Rutas WebSocket
│ │
│ ├── 📁 core/ # Lógica de negocio
│ │ ├── analyzer.py # Análisis de problemas
│ │ ├── method_detector.py # Detección de métodos
│ │ ├── message_parser.py # Parser de mensajes
│ │ ├── recommender_ai.py # Recomendador IA
│ │ ├── scope_guard.py # Validación de alcance
│ │ ├── solver_differential.py
│ │ ├── solver_lagrange.py
│ │ ├── solver_kkt.py
│ │ ├── solver_gradiente.py
│ │ ├── solver_cuadratico.py
│ │ ├── solver_qp_*.py # Solvers QP
│ │ └── visualizer_*.py # Generadores de gráficas
│ │
│ ├── 📁 ai/ # Servicios de IA
│ │ ├── groq_service.py # Cliente Groq API
│ │ └── prompt_contextual.txt
│ │
│ ├── 📁 templates/ # Plantillas HTML
│ │ ├── index.html # Página principal
│ │ └── methods/ # Páginas por método
│ │
│ ├── 📁 static/ # Archivos estáticos
│ │ └── opti_app/
│ │ ├── css/app_v2.css # Estilos principales
│ │ └── js/
│ │ ├── app.js # Chat IA
│ │ └── method.js # Formularios
│ │
│ └── 📁 migrations/ # Migraciones de BD
│
└── 📁 staticfiles/ # Static compilados (generado)
OptiLearn implementa un sistema de 6 reglas para detectar automáticamente qué método usar:
┌─────────────────────────────────────────────────────────────┐
│ ENTRADA DEL USUARIO │
│ (Lenguaje natural o expresión matemática) │
└─────────────────────────────┬───────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ REGLA 1: ¿Pide proceso iterativo? │
│ Keywords: "iterar", "gradiente descendente", "learning rate"│
│ ───────────────────────────────────────────────────────────│
│ SÍ → GRADIENTE DESCENDENTE │
└─────────────────────────────┬───────────────────────────────┘
│ NO
▼
┌─────────────────────────────────────────────────────────────┐
│ REGLA 2: ¿Tiene restricciones NO LINEALES de desigualdad? │
│ Ejemplo: x² + y² ≤ 1 │
│ ───────────────────────────────────────────────────────────│
│ SÍ → KKT │
└─────────────────────────────┬───────────────────────────────┘
│ NO
▼
┌─────────────────────────────────────────────────────────────┐
│ REGLA 3: ¿Tiene SOLO restricciones de IGUALDAD? │
│ Ejemplo: x + y = 1, g(x,y) = 0 │
│ ───────────────────────────────────────────────────────────│
│ SÍ → LAGRANGE │
└─────────────────────────────┬───────────────────────────────┘
│ NO
▼
┌─────────────────────────────────────────────────────────────┐
│ REGLA 4: ¿Función CUADRÁTICA con restricciones LINEALES? │
│ f = ½x'Qx + c'x, Ax ≤ b │
│ ───────────────────────────────────────────────────────────│
│ SÍ → PROGRAMACIÓN CUADRÁTICA (QP) │
└─────────────────────────────┬───────────────────────────────┘
│ NO
▼
┌─────────────────────────────────────────────────────────────┐
│ REGLA 5: ¿Pide derivadas/puntos críticos SIN restricciones? │
│ Keywords: "punto crítico", "máximo", "mínimo", "derivada" │
│ ───────────────────────────────────────────────────────────│
│ SÍ → CÁLCULO DIFERENCIAL │
└─────────────────────────────┬───────────────────────────────┘
│ NO
▼
┌─────────────────────────────────────────────────────────────┐
│ REGLA 6: ANÁLISIS POR ESTRUCTURA │
│ • Con desigualdades → KKT │
│ • Con igualdades → LAGRANGE │
│ • Sin restricciones → DIFERENCIAL │
└─────────────────────────────────────────────────────────────┘
| Prioridad | Método | Condición |
|---|---|---|
| 1 (Alta) | Gradiente | Keywords iterativos detectados |
| 2 | KKT | Restricciones no lineales de desigualdad |
| 3 | Lagrange | Solo restricciones de igualdad |
| 4 | QP | f cuadrática + restricciones lineales |
| 5 | Diferencial | Keywords de derivadas sin restricciones |
| 6 (Baja) | Por estructura | Análisis del problema |
POST /api/problems/parse
Content-Type: application/json
{
"objective_expr": "x**2 + y**2",
"constraints": ["x + y - 1 = 0"]
}Respuesta:
{
"variables": ["x", "y"],
"has_equalities": true,
"has_inequalities": false,
"is_quadratic": true,
"recommended_method": "lagrange"
}POST /api/solve/differential
Content-Type: application/json
{
"objective": "x**3 - 3*x*y + y**3",
"variables": ["x", "y"]
}POST /api/solve/lagrange
Content-Type: application/json
{
"objective": "x**2 + y**2",
"constraints_eq": ["x + y - 1"],
"variables": ["x", "y"]
}POST /api/solve/kkt
Content-Type: application/json
{
"objective": "x**2 + y**2",
"constraints_eq": [],
"constraints_ineq": ["x + y - 1"],
"variables": ["x", "y"]
}POST /api/solve/gradient
Content-Type: application/json
{
"objective": "(1-x)**2 + 100*(y-x**2)**2",
"variables": ["x", "y"],
"initial_point": [0, 0],
"max_iter": 1000,
"tol": 1e-6
}POST /api/solve/qp
Content-Type: application/json
{
"Q": [[2, 0], [0, 2]],
"c": [1, 1],
"A_ub": [[-1, 0], [0, -1]],
"b_ub": [0, 0]
}// Conectar
const ws = new WebSocket('ws://localhost:8000/ws/chat/{session_id}/');
// Enviar mensaje
ws.send(JSON.stringify({
type: 'user_message',
text: 'Minimiza x² + y² sujeto a x + y = 1'
}));
// Recibir respuesta
ws.onmessage = (event) => {
const data = JSON.parse(event.data);
// data.type: 'assistant_message' | 'error' | 'status'
// data.text: Respuesta del asistente
// data.payload: Datos adicionales (gráficas, iteraciones)
};OptiLearn genera visualizaciones automáticas según el problema:
- Función objetivo con curvas de nivel
- Punto óptimo destacado
- Restricciones superpuestas (Lagrange/KKT)
- Superficie de la función objetivo
- Trayectoria de convergencia (Gradiente)
- Punto óptimo con marcador
- Gráfica de convergencia (f vs k)
- Norma del gradiente vs iteración
- Trayectoria en el espacio de variables
# Ejecutar tests
cd opti_learn
python manage.py test
# Tests específicos
python manage.py test opti_app.tests.test_solvers
python manage.py test opti_app.tests.test_analyzer- ✅ Parsing de expresiones matemáticas
- ✅ Detección de tipos de restricciones
- ✅ Convergencia de solvers en problemas conocidos
- ✅ Clasificación de puntos críticos
- ✅ Integridad de endpoints API