# --- INSTALACIÓN DE DEPENDENCIAS ADICIONALES ---
import os
import sys
import subprocess
os.system("pip install --upgrade gradio")
# --- IMPORTACIONES ---
import os
import io
import tempfile
import traceback
import zipfile
from typing import List, Tuple, Dict, Any, Optional, Union
from abc import ABC, abstractmethod
from unittest.mock import MagicMock
from dataclasses import dataclass
from enum import Enum
import json
import base64
from PIL import Image
import gradio as gr
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import plotly.io as pio
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.integrate import odeint
from scipy.optimize import curve_fit, differential_evolution
from sklearn.metrics import mean_squared_error, r2_score
from docx import Document
from docx.shared import Inches
from fpdf import FPDF
from fpdf.enums import XPos, YPos
from fastapi import FastAPI
import uvicorn
# --- SISTEMA DE INTERNACIONALIZACIÓN ---
class Language(Enum):
ES = "Español"
EN = "English"
PT = "Português"
FR = "Français"
DE = "Deutsch"
ZH = "中文"
JA = "日本語"
TRANSLATIONS = {
Language.ES: {
"title": "🔬 Analizador de Cinéticas de Bioprocesos",
"subtitle": "Análisis avanzado de modelos matemáticos biotecnológicos",
"welcome": "Bienvenido al Analizador de Cinéticas",
"upload": "Sube tu archivo Excel (.xlsx)",
"select_models": "Modelos a Probar",
"analysis_mode": "Modo de Análisis",
"analyze": "Analizar y Graficar",
"results": "Resultados",
"download": "Descargar",
"biomass": "Biomasa",
"substrate": "Sustrato",
"product": "Producto",
"time": "Tiempo",
"parameters": "Parámetros",
"model_comparison": "Comparación de Modelos",
"dark_mode": "Modo Oscuro",
"light_mode": "Modo Claro",
"language": "Idioma",
"theory": "Teoría y Modelos",
"guide": "Guía de Uso",
"api_docs": "Documentación API",
"individual": "Individual",
"average": "Promedio",
"combined": "Combinado",
"config": "Configuración"
},
Language.EN: {
"title": "🔬 Bioprocess Kinetics Analyzer",
"subtitle": "Advanced analysis of biotechnological mathematical models",
"welcome": "Welcome to the Kinetics Analyzer",
"upload": "Upload your Excel file (.xlsx)",
"select_models": "Models to Test",
"analysis_mode": "Analysis Mode",
"analyze": "Analyze and Plot",
"results": "Results",
"download": "Download",
"biomass": "Biomass",
"substrate": "Substrate",
"product": "Product",
"time": "Time",
"parameters": "Parameters",
"model_comparison": "Model Comparison",
"dark_mode": "Dark Mode",
"light_mode": "Light Mode",
"language": "Language",
"theory": "Theory and Models",
"guide": "User Guide",
"api_docs": "API Documentation",
"individual": "Individual",
"average": "Average",
"combined": "Combined",
"config": "Configuration"
},
}
# --- CONSTANTES MEJORADAS ---
C_TIME = 'tiempo'
C_BIOMASS = 'biomass'
C_SUBSTRATE = 'substrate'
C_PRODUCT = 'product'
COMPONENTS = [C_BIOMASS, C_SUBSTRATE, C_PRODUCT]
# --- SISTEMA DE TEMAS ---
THEMES = {
"light": gr.themes.Soft(
primary_hue="blue",
secondary_hue="sky",
neutral_hue="gray",
font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "sans-serif"]
),
"dark": gr.themes.Base(
primary_hue="blue",
secondary_hue="cyan",
neutral_hue="slate",
font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "sans-serif"]
).set(
body_background_fill="*neutral_950",
body_background_fill_dark="*neutral_950",
button_primary_background_fill="*primary_600",
button_primary_background_fill_hover="*primary_700",
)
}
# --- MODELOS CINÉTICOS COMPLETOS ---
class KineticModel(ABC):
def __init__(self, name: str, display_name: str, param_names: List[str],
description: str = "", equation: str = "", reference: str = ""):
self.name = name
self.display_name = display_name
self.param_names = param_names
self.num_params = len(param_names)
self.description = description
self.equation = equation
self.reference = reference
@abstractmethod
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
pass
def diff_function(self, X: float, t: float, params: List[float]) -> float:
return 0.0
@abstractmethod
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
pass
@abstractmethod
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
pass
# Modelo Logístico
class LogisticModel(KineticModel):
def __init__(self):
super().__init__(
"logistic",
"Logístico",
["X0", "Xm", "μm"],
"Modelo de crecimiento logístico clásico para poblaciones limitadas",
r"X(t) = \frac{X_0 X_m e^{\mu_m t}}{X_m - X_0 + X_0 e^{\mu_m t}}",
"Verhulst (1838)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
X0, Xm, um = params
if Xm <= 0 or X0 <= 0 or Xm < X0:
return np.full_like(t, np.nan)
exp_arg = np.clip(um * t, -700, 700)
term_exp = np.exp(exp_arg)
denominator = Xm - X0 + X0 * term_exp
denominator = np.where(denominator == 0, 1e-9, denominator)
return (X0 * term_exp * Xm) / denominator
def diff_function(self, X: float, t: float, params: List[float]) -> float:
_, Xm, um = params
return um * X * (1 - X / Xm) if Xm > 0 else 0.0
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [
biomass[0] if len(biomass) > 0 and biomass[0] > 1e-6 else 1e-3,
max(biomass) if len(biomass) > 0 else 1.0,
0.1
]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
initial_biomass = biomass[0] if len(biomass) > 0 else 1e-9
max_biomass = max(biomass) if len(biomass) > 0 else 1.0
return ([1e-9, initial_biomass, 1e-9], [max_biomass * 1.2, max_biomass * 5, np.inf])
# Modelo Gompertz
class GompertzModel(KineticModel):
def __init__(self):
super().__init__(
"gompertz",
"Gompertz",
["Xm", "μm", "λ"],
"Modelo de crecimiento asimétrico con fase lag",
r"X(t) = X_m \exp\left(-\exp\left(\frac{\mu_m e}{X_m}(\lambda-t)+1\right)\right)",
"Gompertz (1825)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
Xm, um, lag = params
if Xm <= 0 or um <= 0:
return np.full_like(t, np.nan)
exp_term = (um * np.e / Xm) * (lag - t) + 1
exp_term_clipped = np.clip(exp_term, -700, 700)
return Xm * np.exp(-np.exp(exp_term_clipped))
def diff_function(self, X: float, t: float, params: List[float]) -> float:
Xm, um, lag = params
k_val = um * np.e / Xm
u_val = k_val * (lag - t) + 1
u_val_clipped = np.clip(u_val, -np.inf, 700)
return X * k_val * np.exp(u_val_clipped) if Xm > 0 and X > 0 else 0.0
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [
max(biomass) if len(biomass) > 0 else 1.0,
0.1,
time[np.argmax(np.gradient(biomass))] if len(biomass) > 1 else 0
]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
initial_biomass = min(biomass) if len(biomass) > 0 else 1e-9
max_biomass = max(biomass) if len(biomass) > 0 else 1.0
return ([max(1e-9, initial_biomass), 1e-9, 0], [max_biomass * 5, np.inf, max(time) if len(time) > 0 else 1])
# Modelo Moser
class MoserModel(KineticModel):
def __init__(self):
super().__init__(
"moser",
"Moser",
["Xm", "μm", "Ks"],
"Modelo exponencial simple de Moser",
r"X(t) = X_m (1 - e^{-\mu_m (t - K_s)})",
"Moser (1958)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
Xm, um, Ks = params
return Xm * (1 - np.exp(-um * (t - Ks))) if Xm > 0 and um > 0 else np.full_like(t, np.nan)
def diff_function(self, X: float, t: float, params: List[float]) -> float:
Xm, um, _ = params
return um * (Xm - X) if Xm > 0 else 0.0
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [max(biomass) if len(biomass) > 0 else 1.0, 0.1, 0]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
initial_biomass = min(biomass) if len(biomass) > 0 else 1e-9
max_biomass = max(biomass) if len(biomass) > 0 else 1.0
return ([max(1e-9, initial_biomass), 1e-9, -np.inf], [max_biomass * 5, np.inf, np.inf])
# Modelo Baranyi
class BaranyiModel(KineticModel):
def __init__(self):
super().__init__(
"baranyi",
"Baranyi",
["X0", "Xm", "μm", "λ"],
"Modelo de Baranyi con fase lag explícita",
r"X(t) = X_m / [1 + ((X_m/X_0) - 1) \exp(-\mu_m A(t))]",
"Baranyi & Roberts (1994)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
X0, Xm, um, lag = params
if X0 <= 0 or Xm <= X0 or um <= 0 or lag < 0:
return np.full_like(t, np.nan)
A_t = t + (1 / um) * np.log(np.exp(-um * t) + np.exp(-um * lag) - np.exp(-um * (t + lag)))
exp_um_At = np.exp(np.clip(um * A_t, -700, 700))
numerator = Xm
denominator = 1 + ((Xm / X0) - 1) * (1 / exp_um_At)
return numerator / np.where(denominator == 0, 1e-9, denominator)
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [
biomass[0] if len(biomass) > 0 and biomass[0] > 1e-6 else 1e-3,
max(biomass) if len(biomass) > 0 else 1.0,
0.1,
time[np.argmax(np.gradient(biomass))] if len(biomass) > 1 else 0.0
]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
initial_biomass = biomass[0] if len(biomass) > 0 else 1e-9
max_biomass = max(biomass) if len(biomass) > 0 else 1.0
return ([1e-9, max(1e-9, initial_biomass), 1e-9, 0], [max_biomass * 1.2, max_biomass * 10, np.inf, max(time) if len(time) > 0 else 1])
# Modelo Monod
class MonodModel(KineticModel):
def __init__(self):
super().__init__(
"monod",
"Monod",
["μmax", "Ks", "Y", "m"],
"Modelo de Monod con mantenimiento celular",
r"\mu = \frac{\mu_{max} \cdot S}{K_s + S} - m",
"Monod (1949)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
# Implementación simplificada para ajuste
μmax, Ks, Y, m = params
# Este es un modelo más complejo que requiere integración numérica
return np.full_like(t, np.nan) # Se usa solo con EDO
def diff_function(self, X: float, t: float, params: List[float]) -> float:
μmax, Ks, Y, m = params
S = 10.0 # Valor placeholder, necesita integrarse con sustrato
μ = (μmax * S / (Ks + S)) - m
return μ * X
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [0.5, 0.1, 0.5, 0.01]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
return ([0.01, 0.001, 0.1, 0.0], [2.0, 5.0, 1.0, 0.1])
# Modelo Contois
class ContoisModel(KineticModel):
def __init__(self):
super().__init__(
"contois",
"Contois",
["μmax", "Ksx", "Y", "m"],
"Modelo de Contois para alta densidad celular",
r"\mu = \frac{\mu_{max} \cdot S}{K_{sx} \cdot X + S} - m",
"Contois (1959)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
return np.full_like(t, np.nan) # Requiere EDO
def diff_function(self, X: float, t: float, params: List[float]) -> float:
μmax, Ksx, Y, m = params
S = 10.0 # Placeholder
μ = (μmax * S / (Ksx * X + S)) - m
return μ * X
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [0.5, 0.5, 0.5, 0.01]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
return ([0.01, 0.01, 0.1, 0.0], [2.0, 10.0, 1.0, 0.1])
# Modelo Andrews
class AndrewsModel(KineticModel):
def __init__(self):
super().__init__(
"andrews",
"Andrews (Haldane)",
["μmax", "Ks", "Ki", "Y", "m"],
"Modelo de inhibición por sustrato",
r"\mu = \frac{\mu_{max} \cdot S}{K_s + S + \frac{S^2}{K_i}} - m",
"Andrews (1968)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
return np.full_like(t, np.nan)
def diff_function(self, X: float, t: float, params: List[float]) -> float:
μmax, Ks, Ki, Y, m = params
S = 10.0 # Placeholder
μ = (μmax * S / (Ks + S + S**2/Ki)) - m
return μ * X
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [0.5, 0.1, 50.0, 0.5, 0.01]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
return ([0.01, 0.001, 1.0, 0.1, 0.0], [2.0, 5.0, 200.0, 1.0, 0.1])
# Modelo Tessier
class TessierModel(KineticModel):
def __init__(self):
super().__init__(
"tessier",
"Tessier",
["μmax", "Ks", "X0"],
"Modelo exponencial de Tessier",
r"\mu = \mu_{max} \cdot (1 - e^{-S/K_s})",
"Tessier (1942)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
μmax, Ks, X0 = params
# Implementación simplificada
return X0 * np.exp(μmax * t * 0.5) # Aproximación
def diff_function(self, X: float, t: float, params: List[float]) -> float:
μmax, Ks, X0 = params
return μmax * X * 0.5 # Simplificado
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [0.5, 1.0, biomass[0] if len(biomass) > 0 else 0.1]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
return ([0.01, 0.1, 1e-9], [2.0, 10.0, 1.0])
# Modelo Richards
class RichardsModel(KineticModel):
def __init__(self):
super().__init__(
"richards",
"Richards",
["A", "μm", "λ", "ν", "X0"],
"Modelo generalizado de Richards",
r"X(t) = A \cdot [1 + \nu \cdot e^{-\mu_m(t-\lambda)}]^{-1/\nu}",
"Richards (1959)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
A, μm, λ, ν, X0 = params
if A <= 0 or μm <= 0 or ν <= 0:
return np.full_like(t, np.nan)
exp_term = np.exp(-μm * (t - λ))
return A * (1 + ν * exp_term) ** (-1/ν)
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [
max(biomass) if len(biomass) > 0 else 1.0,
0.5,
time[len(time)//4] if len(time) > 0 else 1.0,
1.0,
biomass[0] if len(biomass) > 0 else 0.1
]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
max_biomass = max(biomass) if len(biomass) > 0 else 10.0
max_time = max(time) if len(time) > 0 else 100.0
return (
[0.1, 0.01, 0.0, 0.1, 1e-9],
[max_biomass * 2, 5.0, max_time, 10.0, max_biomass]
)
# Modelo Stannard
class StannardModel(KineticModel):
def __init__(self):
super().__init__(
"stannard",
"Stannard",
["Xm", "μm", "λ", "α"],
"Modelo de Stannard modificado",
r"X(t) = X_m \cdot [1 - e^{-\mu_m(t-\lambda)^\alpha}]",
"Stannard et al. (1985)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
Xm, μm, λ, α = params
if Xm <= 0 or μm <= 0 or α <= 0:
return np.full_like(t, np.nan)
t_shifted = np.maximum(t - λ, 0)
return Xm * (1 - np.exp(-μm * t_shifted ** α))
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [
max(biomass) if len(biomass) > 0 else 1.0,
0.5,
0.0,
1.0
]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
max_biomass = max(biomass) if len(biomass) > 0 else 10.0
max_time = max(time) if len(time) > 0 else 100.0
return ([0.1, 0.01, -max_time/10, 0.1], [max_biomass * 2, 5.0, max_time/2, 3.0])
# Modelo Huang
class HuangModel(KineticModel):
def __init__(self):
super().__init__(
"huang",
"Huang",
["Xm", "μm", "λ", "n", "m"],
"Modelo de Huang para fase lag variable",
r"X(t) = X_m \cdot \frac{1}{1 + e^{-\mu_m(t-\lambda-m/n)}}",
"Huang (2008)"
)
def model_function(self, t: np.ndarray, *params: float) -> np.ndarray:
Xm, μm, λ, n, m = params
if Xm <= 0 or μm <= 0 or n <= 0:
return np.full_like(t, np.nan)
return Xm / (1 + np.exp(-μm * (t - λ - m/n)))
def get_initial_params(self, time: np.ndarray, biomass: np.ndarray) -> List[float]:
return [
max(biomass) if len(biomass) > 0 else 1.0,
0.5,
time[len(time)//4] if len(time) > 0 else 1.0,
1.0,
0.5
]
def get_param_bounds(self, time: np.ndarray, biomass: np.ndarray) -> Tuple[List[float], List[float]]:
max_biomass = max(biomass) if len(biomass) > 0 else 10.0
max_time = max(time) if len(time) > 0 else 100.0
return (
[0.1, 0.01, 0.0, 0.1, 0.0],
[max_biomass * 2, 5.0, max_time/2, 10.0, 5.0]
)
# --- REGISTRO ACTUALIZADO DE MODELOS ---
AVAILABLE_MODELS: Dict[str, KineticModel] = {
model.name: model for model in [
LogisticModel(),
GompertzModel(),
MoserModel(),
BaranyiModel(),
MonodModel(),
ContoisModel(),
AndrewsModel(),
TessierModel(),
RichardsModel(),
StannardModel(),
HuangModel()
]
}
# --- CLASE MEJORADA DE AJUSTE ---
class BioprocessFitter:
def __init__(self, kinetic_model: KineticModel, maxfev: int = 50000,
use_differential_evolution: bool = False):
self.model = kinetic_model
self.maxfev = maxfev
self.use_differential_evolution = use_differential_evolution
self.params: Dict[str, Dict[str, float]] = {c: {} for c in COMPONENTS}
self.r2: Dict[str, float] = {}
self.rmse: Dict[str, float] = {}
self.mae: Dict[str, float] = {} # Mean Absolute Error
self.aic: Dict[str, float] = {} # Akaike Information Criterion
self.bic: Dict[str, float] = {} # Bayesian Information Criterion
self.data_time: Optional[np.ndarray] = None
self.data_means: Dict[str, Optional[np.ndarray]] = {c: None for c in COMPONENTS}
self.data_stds: Dict[str, Optional[np.ndarray]] = {c: None for c in COMPONENTS}
self.raw_data: Dict[str, List[np.ndarray]] = {c: [] for c in COMPONENTS} # Para análisis individual
def _get_biomass_at_t(self, t: np.ndarray, p: List[float]) -> np.ndarray:
return self.model.model_function(t, *p)
def _get_initial_biomass(self, p: List[float]) -> float:
if not p: return 0.0
if any(k in self.model.param_names for k in ["Xo", "X0"]):
try:
idx = self.model.param_names.index("Xo") if "Xo" in self.model.param_names else self.model.param_names.index("X0")
return p[idx]
except (ValueError, IndexError): pass
return float(self.model.model_function(np.array([0]), *p)[0])
def _calc_integral(self, t: np.ndarray, p: List[float]) -> Tuple[np.ndarray, np.ndarray]:
X_t = self._get_biomass_at_t(t, p)
if np.any(np.isnan(X_t)): return np.full_like(t, np.nan), np.full_like(t, np.nan)
integral_X = np.zeros_like(X_t)
if len(t) > 1:
dt = np.diff(t, prepend=t[0] - (t[1] - t[0] if len(t) > 1 else 1))
integral_X = np.cumsum(X_t * dt)
return integral_X, X_t
def substrate(self, t: np.ndarray, so: float, p_c: float, q: float, bio_p: List[float]) -> np.ndarray:
integral, X_t = self._calc_integral(t, bio_p)
X0 = self._get_initial_biomass(bio_p)
return so - p_c * (X_t - X0) - q * integral
def product(self, t: np.ndarray, po: float, alpha: float, beta: float, bio_p: List[float]) -> np.ndarray:
integral, X_t = self._calc_integral(t, bio_p)
X0 = self._get_initial_biomass(bio_p)
return po + alpha * (X_t - X0) + beta * integral
def process_data_from_df(self, df: pd.DataFrame) -> None:
try:
time_col = [c for c in df.columns if c[1].strip().lower() == C_TIME][0]
self.data_time = df[time_col].dropna().to_numpy()
min_len = len(self.data_time)
def extract(name: str) -> Tuple[np.ndarray, np.ndarray, List[np.ndarray]]:
cols = [c for c in df.columns if c[1].strip().lower() == name.lower()]
if not cols: return np.array([]), np.array([]), []
reps = [df[c].dropna().values[:min_len] for c in cols]
reps = [r for r in reps if len(r) == min_len]
if not reps: return np.array([]), np.array([]), []
arr = np.array(reps)
mean = np.mean(arr, axis=0)
std = np.std(arr, axis=0, ddof=1) if arr.shape[0] > 1 else np.zeros_like(mean)
return mean, std, reps
# Extraer datos con réplicas individuales
for comp, name in [(C_BIOMASS, 'Biomasa'), (C_SUBSTRATE, 'Sustrato'), (C_PRODUCT, 'Producto')]:
mean, std, reps = extract(name)
self.data_means[comp] = mean
self.data_stds[comp] = std
self.raw_data[comp] = reps
except (IndexError, KeyError) as e:
raise ValueError(f"Estructura de DataFrame inválida. Error: {e}")
def _calculate_metrics(self, y_true: np.ndarray, y_pred: np.ndarray,
n_params: int) -> Dict[str, float]:
"""Calcula métricas adicionales de bondad de ajuste"""
n = len(y_true)
residuals = y_true - y_pred
ss_res = np.sum(residuals**2)
ss_tot = np.sum((y_true - np.mean(y_true))**2)
r2 = 1 - (ss_res / ss_tot) if ss_tot > 0 else 0
rmse = np.sqrt(ss_res / n)
mae = np.mean(np.abs(residuals))
# AIC y BIC
if n > n_params + 1:
aic = n * np.log(ss_res/n) + 2 * n_params
bic = n * np.log(ss_res/n) + n_params * np.log(n)
else:
aic = bic = np.inf
return {
'r2': r2,
'rmse': rmse,
'mae': mae,
'aic': aic,
'bic': bic
}
def _fit_component_de(self, func, t, data, bounds, *args):
"""Ajuste usando evolución diferencial para optimización global"""
def objective(params):
try:
pred = func(t, *params, *args)
if np.any(np.isnan(pred)):
return 1e10
return np.sum((data - pred)**2)
except:
return 1e10
result = differential_evolution(objective, bounds=list(zip(*bounds)),
maxiter=1000, seed=42)
if result.success:
popt = result.x
pred = func(t, *popt, *args)
metrics = self._calculate_metrics(data, pred, len(popt))
return list(popt), metrics
return None, {'r2': np.nan, 'rmse': np.nan, 'mae': np.nan,
'aic': np.nan, 'bic': np.nan}
def _fit_component(self, func, t, data, p0, bounds, sigma=None, *args):
try:
if self.use_differential_evolution:
return self._fit_component_de(func, t, data, bounds, *args)
if sigma is not None:
sigma = np.where(sigma == 0, 1e-9, sigma)
popt, _ = curve_fit(func, t, data, p0, bounds=bounds,
maxfev=self.maxfev, ftol=1e-9, xtol=1e-9,
sigma=sigma, absolute_sigma=bool(sigma is not None))
pred = func(t, *popt, *args)
if np.any(np.isnan(pred)):
return None, {'r2': np.nan, 'rmse': np.nan, 'mae': np.nan,
'aic': np.nan, 'bic': np.nan}
metrics = self._calculate_metrics(data, pred, len(popt))
return list(popt), metrics
except (RuntimeError, ValueError):
return None, {'r2': np.nan, 'rmse': np.nan, 'mae': np.nan,
'aic': np.nan, 'bic': np.nan}
def fit_all_models(self) -> None:
t, bio_m, bio_s = self.data_time, self.data_means[C_BIOMASS], self.data_stds[C_BIOMASS]
if t is None or bio_m is None or len(bio_m) == 0: return
popt_bio = self._fit_biomass_model(t, bio_m, bio_s)
if popt_bio:
bio_p = list(self.params[C_BIOMASS].values())
if self.data_means[C_SUBSTRATE] is not None and len(self.data_means[C_SUBSTRATE]) > 0:
self._fit_substrate_model(t, self.data_means[C_SUBSTRATE], self.data_stds[C_SUBSTRATE], bio_p)
if self.data_means[C_PRODUCT] is not None and len(self.data_means[C_PRODUCT]) > 0:
self._fit_product_model(t, self.data_means[C_PRODUCT], self.data_stds[C_PRODUCT], bio_p)
def _fit_biomass_model(self, t, data, std):
p0, bounds = self.model.get_initial_params(t, data), self.model.get_param_bounds(t, data)
popt, metrics = self._fit_component(self.model.model_function, t, data, p0, bounds, std)
if popt:
self.params[C_BIOMASS] = dict(zip(self.model.param_names, popt))
self.r2[C_BIOMASS] = metrics['r2']
self.rmse[C_BIOMASS] = metrics['rmse']
self.mae[C_BIOMASS] = metrics['mae']
self.aic[C_BIOMASS] = metrics['aic']
self.bic[C_BIOMASS] = metrics['bic']
return popt
def _fit_substrate_model(self, t, data, std, bio_p):
p0, b = [data[0], 0.1, 0.01], ([0, -np.inf, -np.inf], [np.inf, np.inf, np.inf])
popt, metrics = self._fit_component(lambda t, so, p, q: self.substrate(t, so, p, q, bio_p), t, data, p0, b, std)
if popt:
self.params[C_SUBSTRATE] = {'So': popt[0], 'p': popt[1], 'q': popt[2]}
self.r2[C_SUBSTRATE] = metrics['r2']
self.rmse[C_SUBSTRATE] = metrics['rmse']
self.mae[C_SUBSTRATE] = metrics['mae']
self.aic[C_SUBSTRATE] = metrics['aic']
self.bic[C_SUBSTRATE] = metrics['bic']
def _fit_product_model(self, t, data, std, bio_p):
p0, b = [data[0] if len(data)>0 else 0, 0.1, 0.01], ([0, -np.inf, -np.inf], [np.inf, np.inf, np.inf])
popt, metrics = self._fit_component(lambda t, po, a, b: self.product(t, po, a, b, bio_p), t, data, p0, b, std)
if popt:
self.params[C_PRODUCT] = {'Po': popt[0], 'alpha': popt[1], 'beta': popt[2]}
self.r2[C_PRODUCT] = metrics['r2']
self.rmse[C_PRODUCT] = metrics['rmse']
self.mae[C_PRODUCT] = metrics['mae']
self.aic[C_PRODUCT] = metrics['aic']
self.bic[C_PRODUCT] = metrics['bic']
def system_ode(self, y, t, bio_p, sub_p, prod_p):
X, _, _ = y
dXdt = self.model.diff_function(X, t, bio_p)
return [dXdt, -sub_p.get('p',0)*dXdt - sub_p.get('q',0)*X, prod_p.get('alpha',0)*dXdt + prod_p.get('beta',0)*X]
def solve_odes(self, t_fine):
p = self.params
bio_d, sub_d, prod_d = p[C_BIOMASS], p[C_SUBSTRATE], p[C_PRODUCT]
if not bio_d: return None, None, None
try:
bio_p = list(bio_d.values())
y0 = [self._get_initial_biomass(bio_p), sub_d.get('So',0), prod_d.get('Po',0)]
sol = odeint(self.system_ode, y0, t_fine, args=(bio_p, sub_d, prod_d))
return sol[:, 0], sol[:, 1], sol[:, 2]
except:
return None, None, None
def _generate_fine_time_grid(self, t_exp):
return np.linspace(min(t_exp), max(t_exp), 500) if t_exp is not None and len(t_exp) > 1 else np.array([])
def get_model_curves_for_plot(self, t_fine, use_diff):
if use_diff and self.model.diff_function(1, 1, [1]*self.model.num_params) != 0:
return self.solve_odes(t_fine)
X, S, P = None, None, None
if self.params[C_BIOMASS]:
bio_p = list(self.params[C_BIOMASS].values())
X = self.model.model_function(t_fine, *bio_p)
if self.params[C_SUBSTRATE]:
S = self.substrate(t_fine, *list(self.params[C_SUBSTRATE].values()), bio_p)
if self.params[C_PRODUCT]:
P = self.product(t_fine, *list(self.params[C_PRODUCT].values()), bio_p)
return X, S, P
def plot_individual_or_combined(self, cfg, mode):
"""Crea gráficos individuales o combinados con Matplotlib/Seaborn"""
t_exp, t_fine = cfg['time_exp'], self._generate_fine_time_grid(cfg['time_exp'])
X_m, S_m, P_m = self.get_model_curves_for_plot(t_fine, cfg.get('use_differential', False))
sns.set_style(cfg.get('style', 'whitegrid'))
if mode == 'average':
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(10, 15), sharex=True)
fig.suptitle(f"Análisis: {cfg.get('exp_name', '')} ({self.model.display_name})", fontsize=16)
axes = [ax1, ax2, ax3]
else:
fig, ax1 = plt.subplots(figsize=(12, 8))
fig.suptitle(f"Análisis: {cfg.get('exp_name', '')} ({self.model.display_name})", fontsize=16)
ax2 = ax1.twinx()
ax3 = ax1.twinx()
ax3.spines["right"].set_position(("axes", 1.18))
axes = [ax1, ax2, ax3]
data_map = {C_BIOMASS: X_m, C_SUBSTRATE: S_m, C_PRODUCT: P_m}
comb_styles = {
C_BIOMASS: {'c': '#0072B2', 'mc': '#56B4E9', 'm': 'o', 'ls': '-'},
C_SUBSTRATE: {'c': '#009E73', 'mc': '#34E499', 'm': 's', 'ls': '--'},
C_PRODUCT: {'c': '#D55E00', 'mc': '#F0E442', 'm': '^', 'ls': '-.'}
}
for ax, comp in zip(axes, COMPONENTS):
ylabel = cfg.get('axis_labels', {}).get(f'{comp}_label', comp.capitalize())
data = cfg.get(f'{comp}_exp')
std = cfg.get(f'{comp}_std')
model_data = data_map.get(comp)
if mode == 'combined':
s = comb_styles[comp]
pc, lc, ms, ls = s['c'], s['mc'], s['m'], s['ls']
else:
pc = cfg.get(f'{comp}_point_color')
lc = cfg.get(f'{comp}_line_color')
ms = cfg.get(f'{comp}_marker_style')
ls = cfg.get(f'{comp}_line_style')
ax_c = pc if mode == 'combined' else 'black'
ax.set_ylabel(ylabel, color=ax_c)
ax.tick_params(axis='y', labelcolor=ax_c)
if data is not None and len(data) > 0:
if cfg.get('show_error_bars') and std is not None and np.any(std > 0):
ax.errorbar(t_exp, data, yerr=std, fmt=ms, color=pc,
label=f'{comp.capitalize()} (Datos)',
capsize=cfg.get('error_cap_size', 3),
elinewidth=cfg.get('error_line_width', 1))
else:
ax.plot(t_exp, data, ls='', marker=ms, color=pc,
label=f'{comp.capitalize()} (Datos)')
if model_data is not None and len(model_data) > 0:
ax.plot(t_fine, model_data, ls=ls, color=lc,
label=f'{comp.capitalize()} (Modelo)')
if mode == 'average' and cfg.get('show_legend', True):
ax.legend(loc=cfg.get('legend_pos', 'best'))
if mode == 'average' and cfg.get('show_params', True) and self.params[comp]:
decs = cfg.get('decimal_places', 3)
p_txt = '\n'.join([f"{k}={format_number(v, decs)}" for k, v in self.params[comp].items()])
full_txt = f"{p_txt}\nR²={format_number(self.r2.get(comp, 0), 3)}, RMSE={format_number(self.rmse.get(comp, 0), 3)}"
pos_x, ha = (0.95, 'right') if 'right' in cfg.get('params_pos', 'upper right') else (0.05, 'left')
ax.text(pos_x, 0.95, full_txt, transform=ax.transAxes, va='top', ha=ha,
bbox=dict(boxstyle='round,pad=0.4', fc='wheat', alpha=0.7))
if mode == 'combined' and cfg.get('show_legend', True):
h1, l1 = axes[0].get_legend_handles_labels()
h2, l2 = axes[1].get_legend_handles_labels()
h3, l3 = axes[2].get_legend_handles_labels()
axes[0].legend(handles=h1+h2+h3, labels=l1+l2+l3, loc=cfg.get('legend_pos', 'best'))
axes[-1].set_xlabel(cfg.get('axis_labels', {}).get('x_label', 'Tiempo'))
plt.tight_layout()
if mode == 'combined':
fig.subplots_adjust(right=0.8)
return fig
# --- FUNCIONES AUXILIARES ---
def format_number(value: Any, decimals: int) -> str:
"""Formatea un número para su visualización"""
if not isinstance(value, (int, float, np.number)) or pd.isna(value):
return "" if pd.isna(value) else str(value)
decimals = int(decimals)
if decimals == 0:
if 0 < abs(value) < 1:
return f"{value:.2e}"
else:
return str(int(round(value, 0)))
return str(round(value, decimals))
# --- FUNCIONES DE PLOTEO MEJORADAS ---
def plot_model_comparison_matplotlib(plot_config: Dict, models_results: List[Dict]) -> plt.Figure:
"""Crea un gráfico de comparación de modelos estático usando Matplotlib/Seaborn"""
time_exp = plot_config['time_exp']
time_fine = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])._generate_fine_time_grid(time_exp)
num_models = len(models_results)
palettes = {
C_BIOMASS: sns.color_palette("Blues", num_models),
C_SUBSTRATE: sns.color_palette("Greens", num_models),
C_PRODUCT: sns.color_palette("Reds", num_models)
}
line_styles = ['-', '--', '-.', ':']
sns.set_style(plot_config.get('style', 'whitegrid'))
fig, ax1 = plt.subplots(figsize=(12, 8))
# Configuración de los 3 ejes Y
ax1.set_xlabel(plot_config['axis_labels']['x_label'])
ax1.set_ylabel(plot_config['axis_labels']['biomass_label'], color="navy", fontsize=12)
ax1.tick_params(axis='y', labelcolor="navy")
ax2 = ax1.twinx()
ax3 = ax1.twinx()
ax3.spines["right"].set_position(("axes", 1.22))
ax2.set_ylabel(plot_config['axis_labels']['substrate_label'], color="darkgreen", fontsize=12)
ax2.tick_params(axis='y', labelcolor="darkgreen")
ax3.set_ylabel(plot_config['axis_labels']['product_label'], color="darkred", fontsize=12)
ax3.tick_params(axis='y', labelcolor="darkred")
# Dibujar datos experimentales
data_markers = {C_BIOMASS: 'o', C_SUBSTRATE: 's', C_PRODUCT: '^'}
for ax, key, color, face in [(ax1, C_BIOMASS, 'navy', 'skyblue'),
(ax2, C_SUBSTRATE, 'darkgreen', 'lightgreen'),
(ax3, C_PRODUCT, 'darkred', 'lightcoral')]:
data_exp = plot_config.get(f'{key}_exp')
data_std = plot_config.get(f'{key}_std')
if data_exp is not None:
if plot_config.get('show_error_bars') and data_std is not None and np.any(data_std > 0):
ax.errorbar(time_exp, data_exp, yerr=data_std, fmt=data_markers[key],
color=color, label=f'{key.capitalize()} (Datos)', zorder=10,
markersize=8, markerfacecolor=face, markeredgecolor=color,
capsize=plot_config.get('error_cap_size', 3),
elinewidth=plot_config.get('error_line_width', 1))
else:
ax.plot(time_exp, data_exp, ls='', marker=data_markers[key],
label=f'{key.capitalize()} (Datos)', zorder=10, ms=8,
mfc=face, mec=color, mew=1.5)
# Dibujar curvas de los modelos
for i, res in enumerate(models_results):
ls = line_styles[i % len(line_styles)]
model_info = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"]))
model_display_name = model_info.display_name
for key_short, ax, name_long in [('X', ax1, C_BIOMASS), ('S', ax2, C_SUBSTRATE), ('P', ax3, C_PRODUCT)]:
if res.get(key_short) is not None:
ax.plot(time_fine, res[key_short], color=palettes[name_long][i], ls=ls,
label=f'{name_long.capitalize()} ({model_display_name})', alpha=0.9)
fig.subplots_adjust(left=0.3, right=0.78, top=0.92,
bottom=0.35 if plot_config.get('show_params') else 0.1)
if plot_config.get('show_legend'):
h1, l1 = ax1.get_legend_handles_labels()
h2, l2 = ax2.get_legend_handles_labels()
h3, l3 = ax3.get_legend_handles_labels()
fig.legend(h1 + h2 + h3, l1 + l2 + l3, loc='center left',
bbox_to_anchor=(0.0, 0.5), fancybox=True, shadow=True, fontsize='small')
if plot_config.get('show_params'):
total_width = 0.95
box_width = total_width / num_models
start_pos = (1.0 - total_width) / 2
for i, res in enumerate(models_results):
model_info = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"]))
text = f"**{model_info.display_name}**\n" + _generate_model_param_text(res, plot_config.get('decimal_places', 3))
fig.text(start_pos + i * box_width, 0.01, text, transform=fig.transFigure,
fontsize=7.5, va='bottom', ha='left',
bbox=dict(boxstyle='round,pad=0.4', fc='ivory', ec='gray', alpha=0.9))
fig.suptitle(f"Comparación de Modelos: {plot_config.get('exp_name', '')}", fontsize=16)
return fig
def plot_model_comparison_plotly(plot_config: Dict, models_results: List[Dict]) -> go.Figure:
"""Crea un gráfico de comparación de modelos interactivo usando Plotly"""
fig = go.Figure()
time_exp = plot_config['time_exp']
time_fine = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])._generate_fine_time_grid(time_exp)
num_models = len(models_results)
palettes = {
C_BIOMASS: sns.color_palette("Blues", n_colors=num_models).as_hex(),
C_SUBSTRATE: sns.color_palette("Greens", n_colors=num_models).as_hex(),
C_PRODUCT: sns.color_palette("Reds", n_colors=num_models).as_hex()
}
line_styles = ['solid', 'dash', 'dot', 'dashdot']
data_markers = {C_BIOMASS: 'circle-open', C_SUBSTRATE: 'square-open', C_PRODUCT: 'diamond-open'}
for key, y_axis, color in [(C_BIOMASS, 'y1', 'navy'),
(C_SUBSTRATE, 'y2', 'darkgreen'),
(C_PRODUCT, 'y3', 'darkred')]:
data_exp = plot_config.get(f'{key}_exp')
data_std = plot_config.get(f'{key}_std')
if data_exp is not None:
error_y_config = dict(type='data', array=data_std, visible=True) if plot_config.get('show_error_bars') and data_std is not None and np.any(data_std > 0) else None
fig.add_trace(go.Scatter(
x=time_exp, y=data_exp, mode='markers',
name=f'{key.capitalize()} (Datos)',
marker=dict(color=color, size=10, symbol=data_markers[key], line=dict(width=2)),
error_y=error_y_config, yaxis=y_axis, legendgroup="data"))
for i, res in enumerate(models_results):
ls = line_styles[i % len(line_styles)]
model_display_name = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"])).display_name
if res.get('X') is not None:
fig.add_trace(go.Scatter(x=time_fine, y=res['X'], mode='lines',
name=f'Biomasa ({model_display_name})',
line=dict(color=palettes[C_BIOMASS][i], dash=ls),
legendgroup=res["name"]))
if res.get('S') is not None:
fig.add_trace(go.Scatter(x=time_fine, y=res['S'], mode='lines',
name=f'Sustrato ({model_display_name})',
line=dict(color=palettes[C_SUBSTRATE][i], dash=ls),
yaxis='y2', legendgroup=res["name"]))
if res.get('P') is not None:
fig.add_trace(go.Scatter(x=time_fine, y=res['P'], mode='lines',
name=f'Producto ({model_display_name})',
line=dict(color=palettes[C_PRODUCT][i], dash=ls),
yaxis='y3', legendgroup=res["name"]))
if plot_config.get('show_params'):
x_positions = np.linspace(0, 1, num_models * 2 + 1)[1::2]
for i, res in enumerate(models_results):
model_display_name = AVAILABLE_MODELS.get(res["name"], MagicMock(display_name=res["name"])).display_name
text = f"{model_display_name}
" + _generate_model_param_text(res, plot_config.get('decimal_places', 3)).replace('\n', '
')
fig.add_annotation(text=text, align='left', showarrow=False, xref='paper',
yref='paper', x=x_positions[i], y=-0.35, bordercolor='gray',
borderwidth=1, bgcolor='ivory', opacity=0.9)
fig.update_layout(
title=f"Comparación de Modelos (Interactivo): {plot_config.get('exp_name', '')}",
xaxis=dict(domain=[0.18, 0.82]),
yaxis=dict(title=plot_config['axis_labels']['biomass_label'], titlefont=dict(color='navy'),
tickfont=dict(color='navy')),
yaxis2=dict(title=plot_config['axis_labels']['substrate_label'], titlefont=dict(color='darkgreen'),
tickfont=dict(color='darkgreen'), overlaying='y', side='right'),
yaxis3=dict(title=plot_config['axis_labels']['product_label'], titlefont=dict(color='darkred'),
tickfont=dict(color='darkred'), overlaying='y', side='right', position=0.85),
legend=dict(traceorder="grouped", yanchor="middle", y=0.5, xanchor="right", x=-0.15),
margin=dict(l=200, r=150, b=250 if plot_config.get('show_params') else 80, t=80),
template="plotly_white" if plot_config.get('theme', 'light') == 'light' else "plotly_dark",
showlegend=plot_config.get('show_legend', True)
)
return fig
def _generate_model_param_text(result: Dict, decimals: int) -> str:
"""Genera el texto formateado de los parámetros para las cajas de anotación"""
text = ""
for comp in COMPONENTS:
if params := result.get('params', {}).get(comp):
p_str = ', '.join([f"{k}={format_number(v, decimals)}" for k, v in params.items()])
r2 = result.get('r2', {}).get(comp, 0)
rmse = result.get('rmse', {}).get(comp, 0)
text += f"{comp[:4].capitalize()}: {p_str}\n(R²={format_number(r2, 3)}, RMSE={format_number(rmse, 3)})\n"
return text.strip()
# --- FUNCIONES DE DESCARGA Y REPORTES ---
def create_zip_file(image_list: List[Any]) -> Optional[str]:
"""Crea un archivo ZIP con todas las imágenes"""
if not image_list:
gr.Warning("No hay gráficos para descargar.")
return None
try:
zip_buffer = io.BytesIO()
with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
for i, fig in enumerate(image_list):
buf = io.BytesIO()
if isinstance(fig, go.Figure):
buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
elif isinstance(fig, plt.Figure):
fig.savefig(buf, format='png', dpi=200, bbox_inches='tight')
plt.close(fig)
elif isinstance(fig, Image.Image):
fig.save(buf, 'PNG')
else:
continue
buf.seek(0)
zf.writestr(f"grafico_{i+1}.png", buf.read())
with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as tmp:
tmp.write(zip_buffer.getvalue())
return tmp.name
except Exception as e:
traceback.print_exc()
gr.Error(f"Error al crear el archivo ZIP: {e}")
return None
def create_word_report(image_list: List[Any], table_df: pd.DataFrame, decimals: int) -> Optional[str]:
"""Crea un reporte en Word con imágenes y tablas"""
if not image_list and (table_df is None or table_df.empty):
gr.Warning("No hay datos ni gráficos para crear el reporte.")
return None
try:
doc = Document()
doc.add_heading('Reporte de Análisis de Cinéticas', 0)
# Resumen ejecutivo
doc.add_heading('Resumen Ejecutivo', level=1)
doc.add_paragraph(f'Fecha del análisis: {pd.Timestamp.now().strftime("%Y-%m-%d %H:%M")}')
doc.add_paragraph(f'Total de experimentos analizados: {len(table_df["Experimento"].unique()) if table_df is not None and not table_df.empty else 0}')
doc.add_paragraph(f'Modelos utilizados: {", ".join(table_df["Modelo"].unique()) if table_df is not None and not table_df.empty else "N/A"}')
if table_df is not None and not table_df.empty:
doc.add_heading('Tabla de Resultados', level=1)
table = doc.add_table(rows=1, cols=len(table_df.columns), style='Table Grid')
for i, col in enumerate(table_df.columns):
table.cell(0, i).text = str(col)
for _, row in table_df.iterrows():
cells = table.add_row().cells
for i, val in enumerate(row):
cells[i].text = str(format_number(val, decimals))
if image_list:
doc.add_page_break()
doc.add_heading('Gráficos Generados', level=1)
for i, fig in enumerate(image_list):
buf = io.BytesIO()
if isinstance(fig, go.Figure):
buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
elif isinstance(fig, plt.Figure):
fig.savefig(buf, format='png', dpi=200, bbox_inches='tight')
plt.close(fig)
elif isinstance(fig, Image.Image):
fig.save(buf, 'PNG')
else:
continue
buf.seek(0)
doc.add_paragraph(f'Gráfico {i+1}', style='Heading 3')
doc.add_picture(buf, width=Inches(6.0))
doc.add_paragraph('') # Espacio entre imágenes
with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
doc.save(tmp.name)
return tmp.name
except Exception as e:
traceback.print_exc()
gr.Error(f"Error al crear el reporte de Word: {e}")
return None
def create_pdf_report(image_list: List[Any], table_df: pd.DataFrame, decimals: int) -> Optional[str]:
"""Crea un reporte en PDF con imágenes y tablas"""
if not image_list and (table_df is None or table_df.empty):
gr.Warning("No hay datos ni gráficos para crear el reporte.")
return None
try:
pdf = FPDF()
pdf.set_auto_page_break(auto=True, margin=15)
pdf.add_page()
pdf.set_font("Helvetica", 'B', 16)
pdf.cell(0, 10, 'Reporte de Análisis de Cinéticas', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='C')
# Resumen ejecutivo
pdf.ln(10)
pdf.set_font("Helvetica", '', 10)
pdf.cell(0, 10, f'Fecha del análisis: {pd.Timestamp.now().strftime("%Y-%m-%d %H:%M")}',
new_x=XPos.LMARGIN, new_y=YPos.NEXT)
if table_df is not None and not table_df.empty:
pdf.ln(10)
pdf.set_font("Helvetica", 'B', 12)
pdf.cell(0, 10, 'Tabla de Resultados', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
pdf.set_font("Helvetica", 'B', 8)
effective_page_width = pdf.w - 2 * pdf.l_margin
num_cols = len(table_df.columns)
col_width = effective_page_width / num_cols if num_cols > 0 else 0
if num_cols > 15:
pdf.set_font_size(6)
elif num_cols > 10:
pdf.set_font_size(7)
for col in table_df.columns:
pdf.cell(col_width, 10, str(col), border=1, align='C')
pdf.ln()
pdf.set_font("Helvetica", '', 7)
if num_cols > 15:
pdf.set_font_size(5)
elif num_cols > 10:
pdf.set_font_size(6)
for _, row in table_df.iterrows():
for val in row:
pdf.cell(col_width, 10, str(format_number(val, decimals)), border=1, align='R')
pdf.ln()
if image_list:
for i, fig in enumerate(image_list):
pdf.add_page()
pdf.set_font("Helvetica", 'B', 12)
pdf.cell(0, 10, f'Gráfico {i+1}', new_x=XPos.LMARGIN, new_y=YPos.NEXT, align='L')
pdf.ln(5)
buf = io.BytesIO()
if isinstance(fig, go.Figure):
buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
elif isinstance(fig, plt.Figure):
fig.savefig(buf, format='png', dpi=200, bbox_inches='tight')
plt.close(fig)
elif isinstance(fig, Image.Image):
fig.save(buf, 'PNG')
else:
continue
buf.seek(0)
with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img:
tmp_img.write(buf.read())
pdf.image(tmp_img.name, x=None, y=None, w=pdf.w - 20)
os.remove(tmp_img.name)
pdf_bytes = pdf.output()
with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
tmp.write(pdf_bytes)
return tmp.name
except Exception as e:
traceback.print_exc()
gr.Error(f"Error al crear el reporte PDF: {e}")
return None
# --- FUNCIÓN PRINCIPAL DE ANÁLISIS ---
def run_analysis(file, model_names, mode, engine, exp_names, settings):
"""Ejecuta el análisis completo con todos los modos"""
if not file:
return [], pd.DataFrame(), "Error: Sube un archivo Excel.", pd.DataFrame()
if not model_names:
return [], pd.DataFrame(), "Error: Selecciona un modelo.", pd.DataFrame()
try:
xls = pd.ExcelFile(file.name)
except Exception as e:
return [], pd.DataFrame(), f"Error al leer archivo: {e}", pd.DataFrame()
figs = []
results_data = []
msgs = []
exp_list = [n.strip() for n in exp_names.split('\n') if n.strip()]
for i, sheet in enumerate(xls.sheet_names):
exp_name = exp_list[i] if i < len(exp_list) else f"Hoja '{sheet}'"
try:
df = pd.read_excel(xls, sheet_name=sheet, header=[0,1])
reader = BioprocessFitter(list(AVAILABLE_MODELS.values())[0])
reader.process_data_from_df(df)
if reader.data_time is None:
msgs.append(f"WARN: Sin datos de tiempo en '{sheet}'.")
continue
cfg = settings.copy()
cfg.update({'exp_name': exp_name, 'time_exp': reader.data_time})
for c in COMPONENTS:
cfg[f'{c}_exp'] = reader.data_means[c]
cfg[f'{c}_std'] = reader.data_stds[c]
t_fine = reader._generate_fine_time_grid(reader.data_time)
plot_results = []
for m_name in model_names:
if m_name not in AVAILABLE_MODELS:
msgs.append(f"WARN: Modelo '{m_name}' no disponible.")
continue
fitter = BioprocessFitter(AVAILABLE_MODELS[m_name], maxfev=int(settings.get('maxfev', 50000)))
fitter.data_time = reader.data_time
fitter.data_means = reader.data_means
fitter.data_stds = reader.data_stds
fitter.raw_data = reader.raw_data
fitter.fit_all_models()
# Guardar resultados numéricos
row = {'Experimento': exp_name, 'Modelo': fitter.model.display_name}
for c in COMPONENTS:
if fitter.params[c]:
row.update({f'{c.capitalize()}_{k}': v for k, v in fitter.params[c].items()})
row[f'R2_{c.capitalize()}'] = fitter.r2.get(c)
row[f'RMSE_{c.capitalize()}'] = fitter.rmse.get(c)
row[f'MAE_{c.capitalize()}'] = fitter.mae.get(c)
row[f'AIC_{c.capitalize()}'] = fitter.aic.get(c)
row[f'BIC_{c.capitalize()}'] = fitter.bic.get(c)
results_data.append(row)
# Generar gráficos según el modo
if mode in ["average", "combined"]:
if hasattr(fitter, 'plot_individual_or_combined'):
figs.append(fitter.plot_individual_or_combined(cfg, mode))
elif mode == "individual":
# Crear gráficos para cada réplica
for rep_idx, rep_data in enumerate(fitter.raw_data[C_BIOMASS]):
cfg_rep = cfg.copy()
cfg_rep['exp_name'] = f"{exp_name} - Réplica {rep_idx + 1}"
for c in COMPONENTS:
if len(fitter.raw_data[c]) > rep_idx:
cfg_rep[f'{c}_exp'] = fitter.raw_data[c][rep_idx]
cfg_rep[f'{c}_std'] = None # No hay std para réplicas individuales
figs.append(fitter.plot_individual_or_combined(cfg_rep, "average"))
else:
# Modo comparación de modelos
X, S, P = fitter.get_model_curves_for_plot(t_fine, settings.get('use_differential', False))
plot_results.append({
'name': m_name,
'X': X,
'S': S,
'P': P,
'params': fitter.params,
'r2': fitter.r2,
'rmse': fitter.rmse
})
if mode == "model_comparison" and plot_results:
plot_func = plot_model_comparison_plotly if engine == 'Plotly (Interactivo)' else plot_model_comparison_matplotlib
figs.append(plot_func(cfg, plot_results))
except Exception as e:
msgs.append(f"ERROR en '{sheet}': {e}")
traceback.print_exc()
msg = "Análisis completado." + ("\n" + "\n".join(msgs) if msgs else "")
df_res = pd.DataFrame(results_data).dropna(axis=1, how='all')
if not df_res.empty:
# Ordenar columnas
id_c = ['Experimento', 'Modelo']
p_c = sorted([c for c in df_res.columns if '_' in c and not any(m in c for m in ['R2', 'RMSE', 'MAE', 'AIC', 'BIC'])])
m_c = sorted([c for c in df_res.columns if any(m in c for m in ['R2', 'RMSE', 'MAE', 'AIC', 'BIC'])])
df_res = df_res[[c for c in id_c + p_c + m_c if c in df_res.columns]]
# Crear DataFrame formateado para UI
df_ui = df_res.copy()
for c in df_ui.select_dtypes(include=np.number).columns:
df_ui[c] = df_ui[c].apply(lambda x: format_number(x, settings.get('decimal_places', 3)) if pd.notna(x) else '')
else:
df_ui = pd.DataFrame()
return figs, df_ui, msg, df_res
# --- API ENDPOINTS PARA AGENTES DE IA ---
app = FastAPI(title="Bioprocess Kinetics API", version="2.0")
@app.get("/")
def read_root():
return {"message": "Bioprocess Kinetics Analysis API", "version": "2.0"}
@app.post("/api/analyze")
async def analyze_data(
data: Dict[str, List[float]],
models: List[str],
options: Optional[Dict[str, Any]] = None
):
"""Endpoint para análisis de datos cinéticos"""
try:
results = {}
for model_name in models:
if model_name not in AVAILABLE_MODELS:
continue
model = AVAILABLE_MODELS[model_name]
fitter = BioprocessFitter(model)
# Configurar datos
fitter.data_time = np.array(data['time'])
fitter.data_means[C_BIOMASS] = np.array(data.get('biomass', []))
fitter.data_means[C_SUBSTRATE] = np.array(data.get('substrate', []))
fitter.data_means[C_PRODUCT] = np.array(data.get('product', []))
# Ajustar modelo
fitter.fit_all_models()
results[model_name] = {
'parameters': fitter.params,
'metrics': {
'r2': fitter.r2,
'rmse': fitter.rmse,
'mae': fitter.mae,
'aic': fitter.aic,
'bic': fitter.bic
}
}
return {"status": "success", "results": results}
except Exception as e:
return {"status": "error", "message": str(e)}
@app.get("/api/models")
def get_available_models():
"""Retorna lista de modelos disponibles con su información"""
models_info = {}
for name, model in AVAILABLE_MODELS.items():
models_info[name] = {
"display_name": model.display_name,
"parameters": model.param_names,
"description": model.description,
"equation": model.equation,
"reference": model.reference,
"num_params": model.num_params
}
return {"models": models_info}
@app.post("/api/predict")
async def predict_kinetics(
model_name: str,
parameters: Dict[str, float],
time_points: List[float]
):
"""Predice valores usando un modelo y parámetros específicos"""
if model_name not in AVAILABLE_MODELS:
return {"status": "error", "message": f"Model {model_name} not found"}
try:
model = AVAILABLE_MODELS[model_name]
time_array = np.array(time_points)
params = [parameters[name] for name in model.param_names]
predictions = model.model_function(time_array, *params)
return {
"status": "success",
"predictions": predictions.tolist(),
"time_points": time_points
}
except Exception as e:
return {"status": "error", "message": str(e)}
# --- INTERFAZ GRADIO COMPLETA ---
def create_gradio_interface() -> gr.Blocks:
"""Crea la interfaz completa con todas las funcionalidades"""
def change_language(lang_key: str) -> Dict:
"""Cambia el idioma de la interfaz"""
lang = Language[lang_key]
trans = TRANSLATIONS.get(lang, TRANSLATIONS[Language.ES])
return trans["title"], trans["subtitle"]
# Obtener opciones de modelo
MODEL_CHOICES = [(model.display_name, model.name) for model in AVAILABLE_MODELS.values()]
DEFAULT_MODELS = [m.name for m in list(AVAILABLE_MODELS.values())[:4]]
with gr.Blocks(theme=THEMES["light"], css="""
.gradio-container {font-family: 'Inter', sans-serif;}
.theory-box {background-color: #f0f9ff; padding: 20px; border-radius: 10px; margin: 10px 0;}
.dark .theory-box {background-color: #1e293b;}
.model-card {border: 1px solid #e5e7eb; padding: 15px; border-radius: 8px; margin: 10px 0;}
.dark .model-card {border-color: #374151;}
""") as demo:
# Estado para tema e idioma
current_theme = gr.State("light")
current_language = gr.State("ES")
# Header con controles de tema e idioma
with gr.Row():
with gr.Column(scale=8):
title_text = gr.Markdown("# 🔬 Analizador de Cinéticas de Bioprocesos")
subtitle_text = gr.Markdown("Análisis avanzado de modelos matemáticos biotecnológicos")
with gr.Column(scale=2):
with gr.Row():
theme_toggle = gr.Checkbox(label="🌙 Modo Oscuro", value=False)
language_select = gr.Dropdown(
choices=[(lang.value, lang.name) for lang in Language],
value="ES",
label="🌐 Idioma"
)
with gr.Tabs() as tabs:
# --- TAB 1: GUÍA Y FORMATO ---
with gr.TabItem("1. Guía y Formato de Datos"):
with gr.Row():
with gr.Column(scale=2):
gr.Markdown("""
### Bienvenido al Analizador de Cinéticas
Esta herramienta te permite ajustar modelos matemáticos a tus datos de crecimiento microbiano.
**Pasos a seguir:**
1. Prepara tu archivo Excel según el formato especificado a la derecha.
2. Ve a la pestaña **"2. Configuración y Ejecución"**.
3. Sube tu archivo y selecciona los modelos cinéticos que deseas probar.
4. Ajusta las opciones de visualización y análisis según tus preferencias.
5. Haz clic en **"Analizar y Graficar"**.
6. Explora los resultados en la pestaña **"3. Resultados"**.
### Modos de Análisis
- **Individual**: Un gráfico por cada réplica
- **Promedio**: Promedio de réplicas con barras de error
- **Combinado**: Todos los componentes en un solo gráfico
- **Comparación**: Comparación de múltiples modelos
""")
with gr.Column(scale=3):
gr.Markdown("### Formato del Archivo Excel")
gr.Markdown("Usa una **cabecera de dos niveles** para tus datos.")
df_ejemplo = pd.DataFrame({
('Rep1', 'Tiempo'): [0, 2, 4, 6],
('Rep1', 'Biomasa'): [0.1, 0.5, 2.5, 5.0],
('Rep1', 'Sustrato'): [10.0, 9.5, 7.0, 2.0],
('Rep1', 'Producto'): [0.0, 0.1, 0.5, 1.2],
('Rep2', 'Tiempo'): [0, 2, 4, 6],
('Rep2', 'Biomasa'): [0.12, 0.48, 2.6, 5.2],
('Rep2', 'Sustrato'): [10.2, 9.6, 7.1, 2.1],
('Rep2', 'Producto'): [0.0, 0.12, 0.48, 1.1],
})
gr.DataFrame(df_ejemplo, interactive=False, label="Ejemplo de Formato")
# --- TAB 2: CONFIGURACIÓN Y EJECUCIÓN ---
with gr.TabItem("2. Configuración y Ejecución"):
with gr.Row():
with gr.Column(scale=1):
file_input = gr.File(label="Sube tu archivo Excel (.xlsx)", file_types=['.xlsx'])
exp_names_input = gr.Textbox(
label="Nombres de Experimentos (opcional)",
placeholder="Nombre Hoja 1\nNombre Hoja 2\n...",
lines=3,
info="Un nombre por línea, en el mismo orden que las hojas del Excel."
)
model_selection_input = gr.CheckboxGroup(
choices=MODEL_CHOICES,
label="Modelos a Probar",
value=DEFAULT_MODELS
)
analysis_mode_input = gr.Radio(
["individual", "average", "combined", "model_comparison"],
label="Modo de Análisis",
value="average",
info="Individual: por réplica. Average: promedio. Combined: 3 ejes. Comparación: todos los modelos."
)
plotting_engine_input = gr.Radio(
["Seaborn (Estático)", "Plotly (Interactivo)"],
label="Motor Gráfico (en modo Comparación)",
value="Plotly (Interactivo)"
)
with gr.Column(scale=2):
with gr.Accordion("Opciones Generales de Análisis", open=True):
decimal_places_input = gr.Slider(0, 10, value=3, step=1, label="Precisión Decimal")
show_params_input = gr.Checkbox(label="Mostrar Parámetros en Gráfico", value=True)
show_legend_input = gr.Checkbox(label="Mostrar Leyenda en Gráfico", value=True)
use_differential_input = gr.Checkbox(label="Usar EDO para graficar", value=False)
maxfev_input = gr.Number(label="Iteraciones Máximas de Ajuste", value=50000)
with gr.Accordion("Etiquetas de los Ejes", open=True):
with gr.Row():
xlabel_input = gr.Textbox(label="Etiqueta Eje X", value="Tiempo (h)")
with gr.Row():
ylabel_biomass_input = gr.Textbox(label="Etiqueta Biomasa", value="Biomasa (g/L)")
ylabel_substrate_input = gr.Textbox(label="Etiqueta Sustrato", value="Sustrato (g/L)")
ylabel_product_input = gr.Textbox(label="Etiqueta Producto", value="Producto (g/L)")
with gr.Accordion("Opciones de Estilo", open=False):
style_input = gr.Dropdown(
['whitegrid', 'darkgrid', 'white', 'dark', 'ticks'],
label="Estilo General (Matplotlib)",
value='whitegrid'
)
with gr.Row():
with gr.Column():
gr.Markdown("**Biomasa**")
biomass_point_color_input = gr.ColorPicker(label="Color Puntos", value='#0072B2')
biomass_line_color_input = gr.ColorPicker(label="Color Línea", value='#56B4E9')
biomass_marker_style_input = gr.Dropdown(
['o', 's', '^', 'D', 'p', '*', 'X'],
label="Marcador",
value='o'
)
biomass_line_style_input = gr.Dropdown(
['-', '--', '-.', ':'],
label="Estilo Línea",
value='-'
)
with gr.Column():
gr.Markdown("**Sustrato**")
substrate_point_color_input = gr.ColorPicker(label="Color Puntos", value='#009E73')
substrate_line_color_input = gr.ColorPicker(label="Color Línea", value='#34E499')
substrate_marker_style_input = gr.Dropdown(
['o', 's', '^', 'D', 'p', '*', 'X'],
label="Marcador",
value='s'
)
substrate_line_style_input = gr.Dropdown(
['-', '--', '-.', ':'],
label="Estilo Línea",
value='--'
)
with gr.Column():
gr.Markdown("**Producto**")
product_point_color_input = gr.ColorPicker(label="Color Puntos", value='#D55E00')
product_line_color_input = gr.ColorPicker(label="Color Línea", value='#F0E442')
product_marker_style_input = gr.Dropdown(
['o', 's', '^', 'D', 'p', '*', 'X'],
label="Marcador",
value='^'
)
product_line_style_input = gr.Dropdown(
['-', '--', '-.', ':'],
label="Estilo Línea",
value='-.'
)
with gr.Row():
legend_pos_input = gr.Radio(
["best", "upper right", "upper left", "lower left", "lower right", "center"],
label="Posición Leyenda",
value="best"
)
params_pos_input = gr.Radio(
["upper right", "upper left", "lower right", "lower left"],
label="Posición Parámetros",
value="upper right"
)
with gr.Accordion("Opciones de Barra de Error", open=False):
show_error_bars_input = gr.Checkbox(label="Mostrar barras de error", value=True)
error_cap_size_input = gr.Slider(1, 10, 3, step=1, label="Tamaño Tapa Error")
error_line_width_input = gr.Slider(0.5, 5, 1.0, step=0.5, label="Grosor Línea Error")
simulate_btn = gr.Button("Analizar y Graficar", variant="primary")
# --- TAB 3: RESULTADOS ---
with gr.TabItem("3. Resultados"):
status_output = gr.Textbox(label="Estado del Análisis", interactive=False, lines=2)
gallery_output = gr.Gallery(
label="Gráficos Generados",
columns=2,
height=600,
object_fit="contain",
preview=True
)
with gr.Accordion("Descargar Reportes y Gráficos", open=True):
with gr.Row():
zip_btn = gr.Button("📦 Descargar Gráficos (.zip)")
word_btn = gr.Button("📄 Descargar Reporte (.docx)")
pdf_btn = gr.Button("📄 Descargar Reporte (.pdf)")
download_output = gr.File(label="Archivo de Descarga", interactive=False)
gr.Markdown("### Tabla de Resultados Numéricos")
table_output = gr.DataFrame(wrap=True)
with gr.Row():
excel_btn = gr.Button("📊 Descargar Tabla (.xlsx)")
csv_btn = gr.Button("📊 Descargar Tabla (.csv)")
download_table_output = gr.File(label="Descargar Tabla", interactive=False)
# Estados para almacenar datos
df_for_export = gr.State(pd.DataFrame())
figures_for_export = gr.State([])
# --- EVENTOS ---
def simulation_wrapper(file, models, mode, engine, names, use_diff, s_par, s_leg, maxfev,
decimals, x_label, bio_label, sub_label, prod_label, style, s_err,
cap, lw, l_pos, p_pos, bio_pc, bio_lc, bio_ms, bio_ls, sub_pc,
sub_lc, sub_ms, sub_ls, prod_pc, prod_lc, prod_ms, prod_ls):
try:
def rgba_to_hex(rgba_string: str) -> str:
if not isinstance(rgba_string, str) or rgba_string.startswith('#'):
return rgba_string
try:
parts = rgba_string.lower().replace('rgba', '').replace('rgb', '').replace('(', '').replace(')', '')
r, g, b, *_ = map(float, parts.split(','))
return f'#{int(r):02x}{int(g):02x}{int(b):02x}'
except (ValueError, TypeError):
return "#000000"
plot_settings = {
'decimal_places': int(decimals),
'use_differential': use_diff,
'style': style,
'show_legend': s_leg,
'show_params': s_par,
'maxfev': int(maxfev),
'axis_labels': {
'x_label': x_label,
'biomass_label': bio_label,
'substrate_label': sub_label,
'product_label': prod_label
},
'legend_pos': l_pos,
'params_pos': p_pos,
'show_error_bars': s_err,
'error_cap_size': cap,
'error_line_width': lw,
f'{C_BIOMASS}_point_color': rgba_to_hex(bio_pc),
f'{C_BIOMASS}_line_color': rgba_to_hex(bio_lc),
f'{C_BIOMASS}_marker_style': bio_ms,
f'{C_BIOMASS}_line_style': bio_ls,
f'{C_SUBSTRATE}_point_color': rgba_to_hex(sub_pc),
f'{C_SUBSTRATE}_line_color': rgba_to_hex(sub_lc),
f'{C_SUBSTRATE}_marker_style': sub_ms,
f'{C_SUBSTRATE}_line_style': sub_ls,
f'{C_PRODUCT}_point_color': rgba_to_hex(prod_pc),
f'{C_PRODUCT}_line_color': rgba_to_hex(prod_lc),
f'{C_PRODUCT}_marker_style': prod_ms,
f'{C_PRODUCT}_line_style': prod_ls,
}
figures, df_ui, msg, df_export = run_analysis(file, models, mode, engine, names, plot_settings)
# Convertir figuras a imágenes para galería
image_list = []
for fig in figures:
buf = io.BytesIO()
if isinstance(fig, go.Figure):
buf.write(fig.to_image(format="png", scale=2, engine="kaleido"))
elif isinstance(fig, plt.Figure):
fig.savefig(buf, format='png', bbox_inches='tight', dpi=150)
plt.close(fig)
buf.seek(0)
image_list.append(Image.open(buf).convert("RGB"))
return image_list, df_ui, msg, df_export, figures
except Exception as e:
print(f"--- ERROR CAPTURADO EN WRAPPER ---\n{traceback.format_exc()}")
return [], pd.DataFrame(), f"Error Crítico: {e}", pd.DataFrame(), []
all_inputs = [
file_input, model_selection_input, analysis_mode_input, plotting_engine_input, exp_names_input,
use_differential_input, show_params_input, show_legend_input, maxfev_input, decimal_places_input,
xlabel_input, ylabel_biomass_input, ylabel_substrate_input, ylabel_product_input,
style_input, show_error_bars_input, error_cap_size_input, error_line_width_input,
legend_pos_input, params_pos_input,
biomass_point_color_input, biomass_line_color_input, biomass_marker_style_input, biomass_line_style_input,
substrate_point_color_input, substrate_line_color_input, substrate_marker_style_input, substrate_line_style_input,
product_point_color_input, product_line_color_input, product_marker_style_input, product_line_style_input
]
all_outputs = [gallery_output, table_output, status_output, df_for_export, figures_for_export]
simulate_btn.click(fn=simulation_wrapper, inputs=all_inputs, outputs=all_outputs)
# Funciones de descarga
zip_btn.click(fn=create_zip_file, inputs=[figures_for_export], outputs=[download_output])
word_btn.click(
fn=create_word_report,
inputs=[figures_for_export, df_for_export, decimal_places_input],
outputs=[download_output]
)
pdf_btn.click(
fn=create_pdf_report,
inputs=[figures_for_export, df_for_export, decimal_places_input],
outputs=[download_output]
)
def export_table_to_file(df: pd.DataFrame, file_format: str) -> Optional[str]:
if df is None or df.empty:
gr.Warning("No hay datos para exportar.")
return None
suffix = ".xlsx" if file_format == "excel" else ".csv"
with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
if file_format == "excel":
df.to_excel(tmp.name, index=False)
else:
df.to_csv(tmp.name, index=False, encoding='utf-8-sig')
return tmp.name
excel_btn.click(
fn=lambda df: export_table_to_file(df, "excel"),
inputs=[df_for_export],
outputs=[download_table_output]
)
csv_btn.click(
fn=lambda df: export_table_to_file(df, "csv"),
inputs=[df_for_export],
outputs=[download_table_output]
)
# Cambio de idioma
language_select.change(
fn=change_language,
inputs=[language_select],
outputs=[title_text, subtitle_text]
)
# Cambio de tema
def apply_theme(is_dark):
return gr.Info("Tema cambiado. Los nuevos gráficos usarán el tema seleccionado.")
theme_toggle.change(
fn=apply_theme,
inputs=[theme_toggle],
outputs=[]
)
return demo
# --- PUNTO DE ENTRADA PRINCIPAL ---
if __name__ == '__main__':
# Lanzar aplicación Gradio
gradio_app = create_gradio_interface()
gradio_app.launch(share=True, debug=True)