import numpy as np
import pandas as pd
import statsmodels.formula.api as smf
import statsmodels.api as sm
import plotly.graph_objects as go
from scipy.optimize import minimize
import plotly.express as px
from scipy.stats import f
import gradio as gr
import io
import zipfile
import tempfile
from datetime import datetime
import docx
from docx.shared import Inches, Pt
from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
import os
from pyDOE import bbdesign, ccdesign
# --- Clase RSM_ExperimentalDesign ---
class RSM_ExperimentalDesign:
def __init__(self, data, design_type, factor_names, y_name, factor_levels):
"""
Inicializa la clase con los datos del diseño experimental.
Args:
data (pd.DataFrame): Datos del experimento.
design_type (str): Tipo de diseño ('Box-Behnken' o 'Central Compuesto').
factor_names (list): Lista de nombres de los factores.
y_name (str): Nombre de la variable dependiente.
factor_levels (dict): Diccionario con los niveles de cada factor.
"""
self.data = data.copy()
self.design_type = design_type
self.factor_names = factor_names
self.y_name = y_name
self.factor_levels = factor_levels
self.model = None
self.model_simplified = None
self.optimized_results = None
self.optimal_levels = None
self.all_figures = []
self.selected_factors = []
def generate_design(self):
"""
Genera el diseño experimental basado en el tipo especificado y asigna los niveles naturales.
"""
num_factors = len(self.factor_names)
if self.design_type == 'Box-Behnken':
design = bbdesign(num_factors)
elif self.design_type == 'Central Compuesto':
design = ccdesign(num_factors, center=(3, 3)) # Puedes ajustar los puntos centrales si lo deseas
else:
raise ValueError("Tipo de diseño no soportado. Elige 'Box-Behnken' o 'Central Compuesto'.")
# Asignar niveles naturales a las variables
for i, factor in enumerate(self.factor_names):
self.data[factor] = self.coded_to_natural(design[:, i], factor)
return self.data
def coded_to_natural(self, coded_value, variable_name):
"""Convierte un valor codificado a su valor natural."""
levels = self.factor_levels[variable_name]
if len(levels) != 3:
raise ValueError(f"Se requieren exactamente 3 niveles para el factor '{variable_name}'.")
return levels[0] + (coded_value + 1) * (levels[-1] - levels[0]) / 2
def natural_to_coded(self, natural_value, variable_name):
"""Convierte un valor natural a su valor codificado."""
levels = self.factor_levels[variable_name]
return -1 + 2 * (natural_value - levels[0]) / (levels[-1] - levels[0])
def fit_model(self):
"""
Ajusta el modelo de segundo orden completo a los datos.
"""
terms = self.factor_names.copy()
# Términos cuadráticos
terms += [f'I({var}**2)' for var in self.factor_names]
# Términos de interacción
for i in range(len(self.factor_names)):
for j in range(i+1, len(self.factor_names)):
terms.append(f'{self.factor_names[i]}:{self.factor_names[j]}')
formula = f'{self.y_name} ~ ' + ' + '.join(terms)
self.model = smf.ols(formula, data=self.data).fit()
print("Modelo Completo:")
print(self.model.summary())
return self.model, self.pareto_chart(self.model, "Pareto - Modelo Completo")
def fit_simplified_model(self, selected_factors):
"""
Ajusta el modelo simplificado basado en los factores seleccionados.
Args:
selected_factors (list): Lista de factores a incluir en el modelo.
"""
self.selected_factors = selected_factors
terms = selected_factors.copy()
# Términos cuadráticos
terms += [f'I({var}**2)' for var in selected_factors]
formula = f'{self.y_name} ~ ' + ' + '.join(terms)
self.model_simplified = smf.ols(formula, data=self.data).fit()
print("\nModelo Simplificado:")
print(self.model_simplified.summary())
return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
def optimize(self, method='Nelder-Mead'):
"""
Encuentra los niveles óptimos de los factores para maximizar la respuesta usando el modelo simplificado.
"""
if self.model_simplified is None:
print("Error: Ajusta el modelo simplificado primero.")
return
def objective_function(x):
input_data = {var: [x[i]] for i, var in enumerate(self.selected_factors)}
return -self.model_simplified.predict(pd.DataFrame(input_data)).values[0]
# Definir límites codificados para cada factor
bounds = [(-1, 1) for _ in self.selected_factors]
x0 = [0] * len(self.selected_factors)
self.optimized_results = minimize(objective_function, x0, method=method, bounds=bounds)
self.optimal_levels = self.optimized_results.x
# Convertir niveles óptimos de codificados a naturales
optimal_levels_natural = [
self.coded_to_natural(self.optimal_levels[i], self.selected_factors[i])
for i in range(len(self.selected_factors))
]
# Crear la tabla de optimización
optimization_table = pd.DataFrame({
'Variable': self.selected_factors,
'Nivel Óptimo (Natural)': optimal_levels_natural,
'Nivel Óptimo (Codificado)': self.optimal_levels
})
return optimization_table.round(3)
def plot_rsm_individual(self, fixed_variable, fixed_level):
"""
Genera un gráfico de superficie de respuesta (RSM) individual para una configuración específica.
"""
if self.model_simplified is None:
print("Error: Ajusta el modelo simplificado primero.")
return None
varying_variables = [var for var in self.selected_factors if var != fixed_variable]
if len(varying_variables) < 2:
print("Se requieren al menos dos variables para generar un gráfico de superficie.")
return None
var1, var2 = varying_variables[:2] # Solo tomar las dos primeras variables para el gráfico
# Determinar los niveles naturales para las variables que varían
x_natural_levels = self.factor_levels[var1]
y_natural_levels = self.factor_levels[var2]
# Crear una malla de puntos para las variables que varían (en unidades naturales)
x_range_natural = np.linspace(x_natural_levels[0], x_natural_levels[-1], 100)
y_range_natural = np.linspace(y_natural_levels[0], y_natural_levels[-1], 100)
x_grid_natural, y_grid_natural = np.meshgrid(x_range_natural, y_range_natural)
# Convertir la malla de variables naturales a codificadas
x_grid_coded = self.natural_to_coded(x_grid_natural, var1)
y_grid_coded = self.natural_to_coded(y_grid_natural, var2)
# Crear un DataFrame para la predicción con variables codificadas
prediction_data = pd.DataFrame({
var1: x_grid_coded.flatten(),
var2: y_grid_coded.flatten(),
})
# Asignar valores codificados a las otras variables fijas
for var in self.selected_factors:
if var not in [var1, var2]:
prediction_data[var] = self.natural_to_coded(fixed_level, var)
# Calcular los valores predichos
z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid_coded.shape)
# Crear el gráfico de superficie
fig = go.Figure(data=[go.Surface(z=z_pred, x=x_grid_natural, y=y_grid_natural, colorscale='Viridis', opacity=0.7, showscale=True)])
# Añadir líneas de cuadrícula
for i in range(x_grid_natural.shape[0]):
fig.add_trace(go.Scatter3d(
x=x_grid_natural[i, :],
y=y_grid_natural[i, :],
z=z_pred[i, :],
mode='lines',
line=dict(color='gray', width=2),
showlegend=False,
hoverinfo='skip'
))
for j in range(x_grid_natural.shape[1]):
fig.add_trace(go.Scatter3d(
x=x_grid_natural[:, j],
y=y_grid_natural[:, j],
z=z_pred[:, j],
mode='lines',
line=dict(color='gray', width=2),
showlegend=False,
hoverinfo='skip'
))
# Añadir los puntos de los experimentos
experiments_data = self.data.copy()
experiments_data['Predicho'] = self.model_simplified.predict(self.data[self.selected_factors])
colors = px.colors.qualitative.Safe
point_labels = [f"{row[self.y_name]:.3f}" for _, row in experiments_data.iterrows()]
fig.add_trace(go.Scatter3d(
x=experiments_data[var1],
y=experiments_data[var2],
z=experiments_data[self.y_name],
mode='markers+text',
marker=dict(size=4, color=colors[:len(experiments_data)]),
text=point_labels,
textposition='top center',
name='Experimentos'
))
# Añadir etiquetas y título con variables naturales
fig.update_layout(
scene=dict(
xaxis_title=f"{var1} ({self.get_units(var1)})",
yaxis_title=f"{var2} ({self.get_units(var2)})",
zaxis_title=self.y_name,
),
title=f"{self.y_name} vs {var1} y {var2}
{fixed_variable} fijo en {fixed_level:.3f} ({self.get_units(fixed_variable)}) (Modelo Simplificado)",
height=800,
width=1000,
showlegend=True
)
return fig
def get_units(self, variable_name):
"""
Define las unidades de las variables para etiquetas.
Puedes personalizar este método según tus necesidades.
"""
units = {
'Glucosa': 'g/L',
'Extracto_de_Levadura': 'g/L',
'Triptófano': 'g/L',
'AIA_ppm': 'ppm',
# Agrega más unidades según tus variables
}
return units.get(variable_name, '')
def generate_all_plots(self):
"""
Genera todas las gráficas de RSM, variando la variable fija y sus niveles usando el modelo simplificado.
Almacena las figuras en self.all_figures.
"""
if self.model_simplified is None:
print("Error: Ajusta el modelo simplificado primero.")
return
self.all_figures = [] # Resetear la lista de figuras
# Niveles naturales para graficar
for fixed_variable in self.selected_factors:
for level in self.factor_levels[fixed_variable]:
fig = self.plot_rsm_individual(fixed_variable, level)
if fig is not None:
self.all_figures.append(fig)
def pareto_chart(self, model, title):
"""
Genera un diagrama de Pareto para los efectos usando estadísticos F,
incluyendo la línea de significancia.
"""
# Calcular los estadísticos F para cada término
fvalues = model.tvalues[1:]**2 # Excluir la Intercept y convertir t a F
abs_fvalues = np.abs(fvalues)
sorted_idx = np.argsort(abs_fvalues)[::-1]
sorted_fvalues = abs_fvalues[sorted_idx]
sorted_names = fvalues.index[sorted_idx]
# Calcular el valor crítico de F para la línea de significancia
alpha = 0.05 # Nivel de significancia
dof_num = 1 # Grados de libertad del numerador (cada término)
dof_den = model.df_resid # Grados de libertad residuales
f_critical = f.ppf(1 - alpha, dof_num, dof_den)
# Crear el diagrama de Pareto
fig = px.bar(
x=sorted_fvalues.round(3),
y=sorted_names,
orientation='h',
labels={'x': 'Estadístico F', 'y': 'Término'},
title=title
)
fig.update_yaxes(autorange="reversed")
# Agregar la línea de significancia
fig.add_vline(x=f_critical, line_dash="dot",
annotation_text=f"F crítico = {f_critical:.3f}",
annotation_position="bottom right")
return fig
def get_simplified_equation(self):
"""
Retorna la ecuación del modelo simplificado como una cadena de texto.
"""
if self.model_simplified is None:
print("Error: Ajusta el modelo simplificado primero.")
return None
coefficients = self.model_simplified.params
equation = f"{self.y_name} = {coefficients['Intercept']:.3f}"
for term, coef in coefficients.items():
if term != 'Intercept':
if term.startswith('I('):
equation += f" + {coef:.3f}*{term[2:-1]}"
elif ':' in term:
equation += f" + {coef:.3f}*{term}"
else:
equation += f" + {coef:.3f}*{term}"
return equation
def generate_prediction_table(self):
"""
Genera una tabla con los valores actuales, predichos y residuales.
"""
if self.model_simplified is None:
print("Error: Ajusta el modelo simplificado primero.")
return None
self.data['Predicho'] = self.model_simplified.predict(self.data[self.selected_factors])
self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']
return self.data[[self.y_name, 'Predicho', 'Residual']].round(3)
def calculate_contribution_percentage(self):
"""
Calcula el porcentaje de contribución de cada factor usando estadísticos F.
"""
if self.model_simplified is None:
print("Error: Ajusta el modelo simplificado primero.")
return None
# ANOVA del modelo simplificado
anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
# Suma de cuadrados total
ss_total = anova_table['sum_sq'].sum()
# Crear tabla de contribución
contribution_table = pd.DataFrame({
'Fuente de Variación': [],
'Suma de Cuadrados': [],
'Grados de Libertad': [],
'Cuadrado Medio': [],
'F': [],
'Valor p': [],
'% Contribución': []
})
# Calcular estadísticos F y porcentaje de contribución para cada factor
ms_error = anova_table.loc['Residual', 'sum_sq'] / anova_table.loc['Residual', 'df']
# Agregar filas para cada término del modelo
for index, row in anova_table.iterrows():
if index != 'Residual':
factor_name = index
if factor_name.startswith('I('):
factor_name = factor_name[2:-1] # Quitar 'I(' y ')'
ss_factor = row['sum_sq']
df_factor = row['df']
ms_factor = ss_factor / df_factor
f_stat = ms_factor / ms_error
p_value = f.sf(f_stat, df_factor, anova_table.loc['Residual', 'df'])
contribution_percentage = (ss_factor / ss_total) * 100
contribution_table = pd.concat([contribution_table, pd.DataFrame({
'Fuente de Variación': [factor_name],
'Suma de Cuadrados': [ss_factor],
'Grados de Libertad': [df_factor],
'Cuadrado Medio': [ms_factor],
'F': [f_stat],
'Valor p': [p_value],
'% Contribución': [contribution_percentage]
})], ignore_index=True)
# Agregar fila para Cor Total
contribution_table = pd.concat([contribution_table, pd.DataFrame({
'Fuente de Variación': ['Cor Total'],
'Suma de Cuadrados': [ss_total],
'Grados de Libertad': [len(self.data) - 1],
'Cuadrado Medio': [np.nan],
'F': [np.nan],
'Valor p': [np.nan],
'% Contribución': [100]
})], ignore_index=True)
return contribution_table.round(3)
def calculate_detailed_anova(self):
"""
Calcula la tabla ANOVA detallada con la descomposición del error residual.
"""
if self.model_simplified is None:
print("Error: Ajusta el modelo simplificado primero.")
return None
# ANOVA del modelo simplificado
anova_reduced = sm.stats.anova_lm(self.model_simplified, typ=2)
# Suma de cuadrados total
ss_total = np.sum((self.data[self.y_name] - self.data[self.y_name].mean())**2)
# Suma de cuadrados de la regresión
ss_regression = anova_reduced['sum_sq'].sum()
# Grados de libertad de la regresión
df_regression = anova_reduced['df'].sum()
# Suma de cuadrados del error residual
ss_residual = anova_reduced.loc['Residual', 'sum_sq']
df_residual = anova_reduced.loc['Residual', 'df']
# Suma de cuadrados del error puro (si hay réplicas)
duplicates = self.data.duplicated(subset=self.selected_factors, keep=False)
if duplicates.any():
ss_pure_error = self.data[duplicates].groupby(self.selected_factors)[self.y_name].var().sum() * self.data[duplicates].groupby(self.selected_factors).ngroups()
df_pure_error = self.data[duplicates].shape[0] - self.data[duplicates].groupby(self.selected_factors).ngroups()
else:
ss_pure_error = np.nan
df_pure_error = np.nan
# Suma de cuadrados de la falta de ajuste
ss_lack_of_fit = ss_residual - ss_pure_error if not np.isnan(ss_pure_error) else np.nan
df_lack_of_fit = df_residual - df_pure_error if not np.isnan(df_pure_error) else np.nan
# Cuadrados medios
ms_regression = ss_regression / df_regression
ms_residual = ss_residual / df_residual
ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit if not np.isnan(ss_lack_of_fit) else np.nan
ms_pure_error = ss_pure_error / df_pure_error if not np.isnan(ss_pure_error) else np.nan
# Estadísticos F y valores p
f_regression = ms_regression / ms_residual
p_regression = 1 - f.cdf(f_regression, df_regression, df_residual)
f_lack_of_fit = ms_lack_of_fit / ms_pure_error if not np.isnan(ms_lack_of_fit) else np.nan
p_lack_of_fit = 1 - f.cdf(f_lack_of_fit, df_lack_of_fit, df_pure_error) if not np.isnan(f_lack_of_fit) else np.nan
# Crear la tabla ANOVA detallada
detailed_anova_table = pd.DataFrame({
'Fuente de Variación': ['Regresión', 'Residual', 'Falta de Ajuste', 'Error Puro', 'Total'],
'Suma de Cuadrados': [ss_regression, ss_residual, ss_lack_of_fit, ss_pure_error, ss_total],
'Grados de Libertad': [df_regression, df_residual, df_lack_of_fit, df_pure_error, len(self.data) - 1],
'Cuadrado Medio': [ms_regression, ms_residual, ms_lack_of_fit, ms_pure_error, np.nan],
'F': [f_regression, np.nan, f_lack_of_fit, np.nan, np.nan],
'Valor p': [p_regression, np.nan, p_lack_of_fit, np.nan, np.nan]
})
# Reorganizar las filas y resetear el índice
detailed_anova_table = detailed_anova_table.reindex([0, 1, 2, 3, 4]).reset_index(drop=True)
return detailed_anova_table.round(3)
def get_all_tables(self):
"""
Obtiene todas las tablas generadas para ser exportadas a Excel.
"""
prediction_table = self.generate_prediction_table()
contribution_table = self.calculate_contribution_percentage()
anova_table = self.calculate_detailed_anova()
return {
'Predicciones': prediction_table,
'% Contribución': contribution_table,
'ANOVA Detallada': anova_table
}
def save_figures_to_zip(self):
"""
Guarda todas las figuras almacenadas en self.all_figures a un archivo ZIP en memoria.
"""
if not self.all_figures:
return None
zip_buffer = io.BytesIO()
with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
for idx, fig in enumerate(self.all_figures, start=1):
img_bytes = fig.to_image(format="png")
zip_file.writestr(f'Grafico_{idx}.png', img_bytes)
zip_buffer.seek(0)
# Guardar en un archivo temporal
with tempfile.NamedTemporaryFile(delete=False, suffix=".zip") as temp_file:
temp_file.write(zip_buffer.read())
temp_path = temp_file.name
return temp_path
def save_fig_to_bytes(self, fig):
"""
Convierte una figura Plotly a bytes en formato PNG.
"""
return fig.to_image(format="png")
def save_tables_to_excel(self):
"""
Guarda todas las tablas en un archivo Excel con múltiples hojas y retorna la ruta del archivo.
"""
tables = self.get_all_tables()
excel_buffer = io.BytesIO()
with pd.ExcelWriter(excel_buffer, engine='xlsxwriter') as writer:
for sheet_name, table in tables.items():
table.to_excel(writer, sheet_name=sheet_name, index=False)
excel_buffer.seek(0)
excel_bytes = excel_buffer.read()
# Guardar en un archivo temporal
with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as temp_file:
temp_file.write(excel_bytes)
temp_path = temp_file.name
return temp_path
def export_tables_to_word(self, tables_dict):
"""
Exporta las tablas proporcionadas a un documento de Word.
"""
if not tables_dict:
return None
doc = docx.Document()
# Configurar estilo de fuente
style = doc.styles['Normal']
font = style.font
font.name = 'Times New Roman'
font.size = Pt(12)
# Título del informe
titulo = doc.add_heading('Informe de Optimización de Producción de AIA', 0)
titulo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
doc.add_paragraph(f"Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}").alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
doc.add_paragraph('\n') # Espacio
for sheet_name, table in tables_dict.items():
# Añadir título de la tabla
doc.add_heading(sheet_name, level=1)
if table.empty:
doc.add_paragraph("No hay datos disponibles para esta tabla.")
continue
# Añadir tabla al documento
table_doc = doc.add_table(rows=1, cols=len(table.columns))
table_doc.style = 'Light List Accent 1'
# Añadir encabezados
hdr_cells = table_doc.rows[0].cells
for idx, col_name in enumerate(table.columns):
hdr_cells[idx].text = col_name
# Añadir filas de datos
for _, row in table.iterrows():
row_cells = table_doc.add_row().cells
for idx, item in enumerate(row):
row_cells[idx].text = str(item)
doc.add_paragraph('\n') # Espacio entre tablas
# Guardar el documento en un archivo temporal
with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp:
doc.save(tmp.name)
tmp_path = tmp.name
return tmp_path
# --- Funciones para la Interfaz de Gradio ---
def load_data(design_type, factor_names, factor_levels, y_name, data_str):
"""
Carga los datos del diseño experimental desde las entradas y crea la instancia de RSM_ExperimentalDesign.
"""
try:
# Parsear nombres de factores
factor_names = [fn.strip() for fn in factor_names.split(',')]
num_factors = len(factor_names)
# Parsear niveles de factores
factor_levels_dict = {}
levels = factor_levels.split(';')
if len(levels) != num_factors:
raise ValueError(f"Se esperaban {num_factors} conjuntos de niveles separados por ';'.")
for i, level_str in enumerate(levels):
level_values = [float(x.strip()) for x in level_str.split(',')]
if len(level_values) != 3:
raise ValueError(f"El factor '{factor_names[i]}' requiere exactamente 3 niveles separados por comas.")
factor_levels_dict[factor_names[i]] = level_values
# Crear DataFrame a partir de la cadena de datos
data_list = [row.split(',') for row in data_str.strip().split('\n')]
column_names = ['Exp.'] + factor_names + [y_name]
data = pd.DataFrame(data_list, columns=column_names)
data = data.apply(pd.to_numeric, errors='coerce') # Convertir a numérico
# Crear la instancia de RSM_ExperimentalDesign
global rsm
rsm = RSM_ExperimentalDesign(
data=data,
design_type=design_type,
factor_names=factor_names,
y_name=y_name,
factor_levels=factor_levels_dict
)
# Generar el diseño
rsm.generate_design()
return data.round(3), gr.update(visible=True), factor_names
except Exception as e:
# Mostrar mensaje de error
error_message = f"Error al cargar los datos: {str(e)}"
print(error_message)
return None, gr.update(visible=False), []
def fit_and_optimize_model(selected_factors):
if 'rsm' not in globals():
return [None]*11 # Ajustar el número de outputs
if not selected_factors:
return [None]*11 # No se han seleccionado factores
# Ajustar modelos y optimizar
model_completo, pareto_completo = rsm.fit_model()
rsm.selected_factors = selected_factors
model_simplificado, pareto_simplificado = rsm.fit_simplified_model(selected_factors)
optimization_table = rsm.optimize()
equation = rsm.get_simplified_equation()
prediction_table = rsm.generate_prediction_table()
contribution_table = rsm.calculate_contribution_percentage()
anova_table = rsm.calculate_detailed_anova()
# Generar todas las figuras y almacenarlas
rsm.generate_all_plots()
# Formatear la ecuación para que se vea mejor en Markdown
if equation:
equation_formatted = equation.replace(" + ", "
+ ").replace(" ** ", "^").replace("*", " × ")
equation_formatted = f"### Ecuación del Modelo Simplificado:
{equation_formatted}"
else:
equation_formatted = "No se pudo generar la ecuación del modelo simplificado."
# Guardar las tablas en Excel temporal
excel_path = rsm.save_tables_to_excel()
# Guardar todas las figuras en un ZIP temporal
zip_path = rsm.save_figures_to_zip()
return (
model_completo.summary().as_html(),
pareto_completo,
model_simplificado.summary().as_html(),
pareto_simplificado,
equation_formatted,
optimization_table,
prediction_table,
contribution_table,
anova_table,
zip_path, # Ruta del ZIP de gráficos
excel_path # Ruta del Excel de tablas
)
def download_current_plot(all_figures, current_index):
"""
Descarga la figura actual como PNG.
"""
if not all_figures:
return None
fig = all_figures[current_index]
img_bytes = rsm.save_fig_to_bytes(fig)
filename = f"Grafico_RSM_{current_index + 1}.png"
return (filename, img_bytes)
def download_all_plots_zip():
"""
Descarga todas las figuras en un archivo ZIP.
"""
if 'rsm' not in globals():
return None
zip_path = rsm.save_figures_to_zip()
if zip_path:
with open(zip_path, 'rb') as f:
zip_bytes = f.read()
filename = f"Graficos_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
return (filename, zip_bytes)
return None
def download_all_tables_excel():
"""
Descarga todas las tablas en un archivo Excel con múltiples hojas.
"""
if 'rsm' not in globals():
return None
excel_path = rsm.save_tables_to_excel()
if excel_path:
with open(excel_path, 'rb') as f:
excel_bytes = f.read()
filename = f"Tablas_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
return (filename, excel_bytes)
return None
def exportar_word(tables_dict):
"""
Función para exportar las tablas a un documento de Word.
"""
if not tables_dict:
return None
word_path = rsm.export_tables_to_word(tables_dict)
if word_path and os.path.exists(word_path):
with open(word_path, 'rb') as f:
word_bytes = f.read()
filename = f"Tablas_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
return (filename, word_bytes)
return None
# --- Crear la interfaz de Gradio ---
def create_gradio_interface():
with gr.Blocks() as demo:
gr.Markdown("# Optimización de la Producción de AIA usando RSM")
with gr.Row():
with gr.Column():
gr.Markdown("## Configuración del Diseño")
design_type_input = gr.Dropdown(
label="Tipo de Diseño",
choices=["Box-Behnken", "Central Compuesto"],
value="Box-Behnken"
)
factor_names_input = gr.Textbox(
label="Nombres de los Factores (separados por comas)",
value="Glucosa, Extracto_de_Levadura, Triptófano"
)
factor_levels_input = gr.Textbox(
label="Niveles de los Factores (cada conjunto separado por ';' y niveles separados por comas)",
value="1, 3.5, 5.5; 0.03, 0.2, 0.3; 0.4, 0.65, 0.9"
)
y_name_input = gr.Textbox(
label="Nombre de la Variable Dependiente (ej. AIA_ppm)",
value="AIA_ppm"
)
data_input = gr.Textbox(
label="Datos del Experimento (formato CSV)",
lines=10,
value="""1,-1,-1,0,166.594
2,1,-1,0,177.557
3,-1,1,0,127.261
4,1,1,0,147.573
5,-1,0,-1,188.883
6,1,0,-1,224.527
7,-1,0,1,190.238
8,1,0,1,226.483
9,0,-1,-1,195.550
10,0,1,-1,149.493
11,0,-1,1,187.683
12,0,1,1,148.621
13,0,0,0,278.951
14,0,0,0,297.238
15,0,0,0,280.896"""
)
load_button = gr.Button("Cargar Datos")
with gr.Column():
gr.Markdown("## Datos Cargados")
data_output = gr.Dataframe(label="Tabla de Datos", interactive=False)
# Sección de análisis visible solo después de cargar los datos
with gr.Row(visible=False) as analysis_row:
with gr.Column():
fit_button = gr.Button("Ajustar Modelo y Optimizar")
gr.Markdown("**Modelo Completo**")
model_completo_output = gr.HTML()
pareto_completo_output = gr.Plot()
gr.Markdown("**Modelo Simplificado**")
model_simplificado_output = gr.HTML()
pareto_simplificado_output = gr.Plot()
gr.Markdown("**Ecuación del Modelo Simplificado**")
equation_output = gr.HTML()
gr.Markdown("**Tabla de Optimización**")
optimization_table_output = gr.Dataframe(label="Tabla de Optimización", interactive=False)
gr.Markdown("**Tabla de Predicciones**")
prediction_table_output = gr.Dataframe(label="Tabla de Predicciones", interactive=False)
gr.Markdown("**Tabla de % de Contribución**")
contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución", interactive=False)
gr.Markdown("**Tabla ANOVA Detallada**")
anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada", interactive=False)
gr.Markdown("## Descargar Todas las Tablas")
download_excel_button = gr.DownloadButton(label="Descargar Tablas en Excel")
download_word_button = gr.DownloadButton(label="Descargar Tablas en Word")
with gr.Column():
gr.Markdown("## Selección de Factores para el Modelo Simplificado")
selected_factors_input = gr.CheckboxGroup(
label="Selecciona los Factores a Incluir",
choices=[], # Actualizar dinámicamente
value=[]
)
fit_button_2 = gr.Button("Aplicar Selección de Factores")
gr.Markdown("## Generar Gráficos de Superficie de Respuesta")
plot_button = gr.Button("Generar Gráficos")
with gr.Row():
left_button = gr.Button("<")
right_button = gr.Button(">")
rsm_plot_output = gr.Plot()
plot_info = gr.Textbox(label="Información del Gráfico", value="Gráfico 1 de 0", interactive=False)
with gr.Row():
download_plot_button = gr.DownloadButton(label="Descargar Gráfico Actual (PNG)")
download_all_plots_button = gr.DownloadButton(label="Descargar Todos los Gráficos (ZIP)")
current_index_state = gr.State(0) # Estado para el índice actual
all_figures_state = gr.State([]) # Estado para todas las figuras
# Funciones de carga y ajuste
def load_data_interface(design_type, factor_names, factor_levels, y_name, data_str):
data, analysis_visibility, factor_names_list = load_data(design_type, factor_names, factor_levels, y_name, data_str)
if data is not None:
# Actualizar las opciones de selección de factores
selected_factors = factor_names_list
return data, analysis_visibility, selected_factors
else:
return data, analysis_visibility, []
load_button.click(
load_data_interface,
inputs=[design_type_input, factor_names_input, factor_levels_input, y_name_input, data_input],
outputs=[data_output, analysis_row, selected_factors_input]
)
# Ajustar modelo y optimizar
fit_button.click(
fit_and_optimize_model,
inputs=[selected_factors_input],
outputs=[
model_completo_output,
pareto_completo_output,
model_simplificado_output,
pareto_simplificado_output,
equation_output,
optimization_table_output,
prediction_table_output,
contribution_table_output,
anova_table_output,
download_all_plots_button,
download_excel_button
]
)
# Conectar los botones de descarga de tablas
download_excel_button.click(
fn=download_all_tables_excel,
inputs=[],
outputs=download_excel_button
)
download_word_button.click(
fn=exportar_word,
inputs=[gr.State()],
outputs=download_word_button
)
# Generar y mostrar los gráficos
def generate_plots():
if 'rsm' not in globals() or not rsm.all_figures:
return None, "No hay gráficos disponibles.", 0, []
# Mostrar el primer gráfico
return rsm.all_figures[0], f"Gráfico 1 de {len(rsm.all_figures)}", 0, rsm.all_figures
plot_button.click(
generate_plots,
inputs=[],
outputs=[rsm_plot_output, plot_info, current_index_state, all_figures_state]
)
# Navegación de gráficos
def navigate(direction, current_index, all_figures):
if not all_figures:
return None, "No hay gráficos disponibles.", current_index
if direction == 'left':
new_index = (current_index - 1) % len(all_figures)
elif direction == 'right':
new_index = (current_index + 1) % len(all_figures)
else:
new_index = current_index
selected_fig = all_figures[new_index]
plot_info_text = f"Gráfico {new_index + 1} de {len(all_figures)}"
return selected_fig, plot_info_text, new_index
left_button.click(
navigate,
inputs=[gr.Button("left"), current_index_state, all_figures_state],
outputs=[rsm_plot_output, plot_info, current_index_state]
)
right_button.click(
navigate,
inputs=[gr.Button("right"), current_index_state, all_figures_state],
outputs=[rsm_plot_output, plot_info, current_index_state]
)
# Descargar gráfico actual
download_plot_button.click(
download_current_plot,
inputs=[all_figures_state, current_index_state],
outputs=download_plot_button
)
# Descargar todos los gráficos en ZIP
download_all_plots_button.click(
download_all_plots_zip,
inputs=[],
outputs=download_all_plots_button
)
# Ejemplo de uso
gr.Markdown("## Ejemplo de uso")
gr.Markdown("""
1. **Configura el Diseño:**
- Selecciona el tipo de diseño (Box-Behnken o Central Compuesto).
- Ingresa los nombres de los factores separados por comas.
- Ingresa los niveles para cada factor separados por comas y cada conjunto de niveles por ';'.
- Especifica el nombre de la variable dependiente.
- Proporciona los datos del experimento en formato CSV.
2. **Cargar Datos:**
- Haz clic en 'Cargar Datos' para cargar y visualizar los datos.
3. **Seleccionar Factores para el Modelo Simplificado:**
- Marca los factores que deseas incluir en el modelo simplificado.
4. **Ajustar Modelo y Optimizar:**
- Haz clic en 'Ajustar Modelo y Optimizar' para ajustar los modelos y obtener los resultados.
5. **Generar y Navegar Gráficos:**
- Haz clic en 'Generar Gráficos' para crear las superficies de respuesta.
- Navega entre los gráficos usando los botones '<' y '>'.
- Descarga el gráfico actual en PNG o todos los gráficos en un archivo ZIP.
6. **Descargar Tablas:**
- Descarga todas las tablas generadas en un archivo Excel o Word.
""")
return demo
# --- Función Principal ---
def main():
interface = create_gradio_interface()
interface.launch(share=True)
if __name__ == "__main__":
main()