Create app.py

app.py

@@ -0,0 +1,413 @@
+### IMPORTACIONES
+import numpy as np
+import pandas as pd
+import random
+import multiprocessing
+import io
+import math
+import os
+import gradio as gr
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import base64
+import sys
+
+# La concurrencia con multiprocessing puede ser problemática en algunos entornos de hosting
+# como Hugging Face Spaces. Usaremos el método 'spawn' explícitamente si es necesario.
+# Sin embargo, para simplificar y asegurar compatibilidad, priorizaremos la versión Serial Optimizado.
+# Si el método 'Concurrente' falla, se recomienda eliminarlo o usar una alternativa más segura.
+try:
+    if sys.platform == "linux" and "multiprocessing" in sys.modules:
+        multiprocessing.set_start_method('spawn', force=True)
+except Exception as e:
+    # print(f"Advertencia al configurar start_method: {e}")
+    pass
+
+
+### --- MODIFICACIÓN CLAVE 1: RUTA Y CARGA DE IMÁGENES ---
+# Las imágenes se asumen en la raíz del repositorio.
+IMAGEN_PORTADA_PATH = "ImagenPortada.jpg"
+IMAGEN_ENCABEZADO_PATH = "ImagenEncabezado.jpg"
+
+# El módulo 'base64' se sigue usando porque es la forma más compatible de incluir
+# imágenes en el CSS personalizado de Gradio.
+
+def cargar_imagen_base64(path):
+    """Carga una imagen local y la convierte a string Base64."""
+    try:
+        # Intentamos cargar la imagen localmente desde el repositorio
+        with open(path, "rb") as f:
+            encoded_image = base64.b64encode(f.read()).decode("utf-8")
+        # Devolvemos la cadena Base64 con el prefijo de imagen
+        return f"data:image/jpeg;base64,{encoded_image}", ""
+    except FileNotFoundError:
+        # Si la imagen no se encuentra (posible en ciertos entornos de build),
+        # usamos un fallback y devolvemos un mensaje de error.
+        error_msg = f"ERROR: No se encontró el archivo en la ruta: {path}. Usando fallback."
+        return "none", error_msg
+
+IMAGEN_PORTADA, PORTADA_ERROR = cargar_imagen_base64(IMAGEN_PORTADA_PATH)
+IMAGEN_ENCABEZADO, ENCABEZADO_ERROR = cargar_imagen_base64(IMAGEN_ENCABEZADO_PATH)
+
+# print(PORTADA_ERROR) # Opcional: imprimir los errores si existen
+# print(ENCABEZADO_ERROR)
+
+
+### DATOS DE ENTRADA (Mantenemos la carga desde string para no depender de archivos externos)
+data_str = """
+Piloto,Ptos,Media,Desv. STD,Probab_DNF
+Lando Norris,357,19.83333,5.613796,0.111111111
+Oscar Piastri,356,18.73684,7.553729,0.052631579
+Max Verstappen,321,16.89474,8.368358,0.052631579
+George Russell,258,13.57895,6.546216,0.052631579
+Carlos Leclerc,210,11.66667,5.290113,0.111111111
+"""
+
+df_parametros_calculados = pd.read_csv(io.StringIO(data_str))
+
+pilotos_data_from_excel = {}
+for index, row in df_parametros_calculados.iterrows():
+    pilotos_data_from_excel[row['Piloto']] = {
+        'mu': row['Media'],
+        'sigma': row['Desv. STD'],
+        'dnf_prob': row['Probab_DNF']
+    }
+
+pilotos_nombres_simulacion = list(pilotos_data_from_excel.keys())
+num_carreras = 22 # Ajustar según el número de carreras en la temporada 2025
+
+
+### FUNCIONES DE SIMULACIÓN (Se mantienen, pero se elimina la necesidad de 'multiprocessing' si causa problemas)
+
+def simular_carrera(piloto_data):
+    """Simula los puntos de un piloto en una carrera."""
+    if random.random() < piloto_data['dnf_prob']:
+        return 0 # DNF o no puntuó
+    return max(0, round(np.random.normal(piloto_data['mu'], piloto_data['sigma'])))
+
+# La función monte_carlo_serial_optimizado (usando NumPy) es la mejor opción para HF.
+def monte_carlo_serial_optimizado(num_simulaciones, pilotos_data, pilotos_nombres, num_carreras, target_driver):
+    """Simulación Monte Carlo optimizada con NumPy."""
+    mus = np.array([pilotos_data[p]['mu'] for p in pilotos_nombres])
+    sigmas = np.array([pilotos_data[p]['sigma'] for p in pilotos_nombres])
+    dnf_probs = np.array([pilotos_data[p]['dnf_prob'] for p in pilotos_nombres])
+
+    # Generar todas las bases de puntos y máscaras DNF a la vez
+    base_points = np.random.normal(mus, sigmas, size=(num_simulaciones, num_carreras, len(pilotos_nombres)))
+    dnf_mask = np.random.rand(num_simulaciones, num_carreras, len(pilotos_nombres)) < dnf_probs
+
+    # Aplicar DNF y redondear
+    final_points = np.where(dnf_mask, 0, np.maximum(0, np.round(base_points))).astype(int)
+
+    # Sumar puntos por temporada
+    temporada_scores = np.sum(final_points, axis=1)
+
+    # Encontrar el índice del campeón en cada simulación
+    campeones_indices = np.argmax(temporada_scores, axis=1)
+
+    # Contar cuántas veces ganó el piloto objetivo
+    target_driver_index = pilotos_nombres.index(target_driver)
+    target_driver_campeon_count = np.sum(campeones_indices == target_driver_index)
+
+    return target_driver_campeon_count
+
+# La función monte_carlo_concurrente queda en desuso o se usa con precaución.
+# Se recomienda usar solo 'Serial Optimizado' en entornos de hosting limitados.
+# Mantenemos el código si el usuario desea probarlo y acepta el riesgo de error.
+# ... (código de monte_carlo_serial y monte_carlo_concurrente sin cambios sustanciales en la lógica) ...
+
+# Funciones worker y wrapper para concurrencia (se mantienen para que el código funcione
+# si el usuario selecciona "Concurrente", pero con la advertencia de compatibilidad)
+def simular_temporada_worker_concurrent(pilotos_data_param, pilotos_nombres_param,
+                                        num_carreras_param, target_driver_name_param):
+    # Asegurar seeds únicos por proceso
+    np.random.seed(os.getpid() + random.randint(0, 10000))
+    random.seed(os.getpid() + random.randint(0, 10000))
+
+    puntos_temporada = {piloto: 0 for piloto in pilotos_nombres_param}
+
+    for _ in range(num_carreras_param):
+        for piloto in pilotos_nombres_param:
+            if random.random() < pilotos_data_param[piloto]['dnf_prob']:
+                puntos = 0
+            else:
+                puntos = max(0, round(np.random.normal(pilotos_data_param[piloto]['mu'], pilotos_data_param[piloto]['sigma'])))
+            puntos_temporada[piloto] += puntos
+
+    if not puntos_temporada or all(pts == 0 for pts in puntos_temporada.values()):
+        campeon_actual = pilotos_nombres_param[0] if pilotos_nombres_param else None
+    else:
+        campeon_actual = max(puntos_temporada, key=puntos_temporada.get)
+
+    return 1 if campeon_actual == target_driver_name_param else 0
+
+def worker_function_concurrent_wrapper(args):
+    num_sims_per_worker, pilotos_data_param, pilotos_nombres_param, num_carreras_param, target_driver_name_param = args
+    local_target_driver_campeon_count = 0
+    for _ in range(num_sims_per_worker):
+        local_target_driver_campeon_count += simular_temporada_worker_concurrent(
+            pilotos_data_param, pilotos_nombres_param, num_carreras_param, target_driver_name_param
+        )
+    return local_target_driver_campeon_count
+
+def monte_carlo_concurrente(num_simulaciones, pilotos_data, pilotos_nombres, num_carreras, target_driver):
+    num_processes = multiprocessing.cpu_count() if multiprocessing.cpu_count() else 2
+    # print(f"Usando {num_processes} procesos para la simulación concurrente.") # Descomentar para debug en HF
+
+    sims_per_process = [num_simulaciones // num_processes] * num_processes
+    for i in range(num_simulaciones % num_processes):
+        sims_per_process[i] += 1
+
+    args_for_pool = [
+        (sims, pilotos_data, pilotos_nombres, num_carreras, target_driver) for sims in sims_per_process
+    ]
+
+    # Usar 'with' asegura que el pool se cierre
+    with multiprocessing.Pool(num_processes) as pool:
+        results = pool.map(worker_function_concurrent_wrapper, args_for_pool)
+
+    total_target_driver_campeon_count = sum(results)
+    return total_target_driver_campeon_count
+
+# Función auxiliar (serial, la versión simple)
+def monte_carlo_serial(num_simulaciones, pilotos_data, pilotos_nombres, num_carreras, target_driver):
+    target_driver_campeon_count = 0
+    for _ in range(num_simulaciones):
+        puntos_temporada = {piloto: 0 for piloto in pilotos_nombres}
+        for _ in range(num_carreras):
+            for piloto in pilotos_nombres:
+                puntos_temporada[piloto] += simular_carrera(pilotos_data[piloto])
+
+        # ... (Lógica para determinar el campeón y contar) ...
+        if not puntos_temporada or all(pts == 0 for pts in puntos_temporada.values()):
+            campeon_actual = pilotos_nombres[0] if pilotos_nombres else None
+        else:
+            campeon_actual = max(puntos_temporada, key=puntos_temporada.get)
+
+        if campeon_actual == target_driver:
+            target_driver_campeon_count += 1
+    return target_driver_campeon_count
+
+# ... (El resto de las funciones create_data_viz_tab y run_simulation se mantienen sin cambios) ...
+
+def create_data_viz_tab():
+    # 1. Raw Data Table
+    data_table = gr.Dataframe(
+        value=df_parametros_calculados,
+        headers=list(df_parametros_calculados.columns),
+        datatype=[
+            "str", "number", "number", "number", "number"
+        ],
+        row_count=len(df_parametros_calculados),
+        col_count=len(df_parametros_calculados.columns),
+        label="Parámetros de Pilotos (Temporada 2025)",
+        interactive=False,
+        wrap=True
+    )
+
+
+    ### GRÁFICO DE PUNTOS ACUMULADOS
+    fig_accumulated = go.Figure()
+
+    simulated_season_points = {piloto: [0] for piloto in pilotos_nombres_simulacion}
+
+    for race_num in range(num_carreras):
+        for piloto in pilotos_nombres_simulacion:
+            current_points = simular_carrera(pilotos_data_from_excel[piloto])
+            simulated_season_points[piloto].append(simulated_season_points[piloto][-1] + current_points)
+
+    for piloto, points_list in simulated_season_points.items():
+        fig_accumulated.add_trace(go.Scatter(x=list(range(num_carreras + 1)),
+                                             y=points_list, mode='lines+markers', name=piloto))
+
+    fig_accumulated.update_layout(
+        title="Puntaje Acumulado por Carrera (Simulación de Temporada 2025)",
+        xaxis_title="N��mero de Carrera",
+        yaxis_title="Puntos Acumulados",
+        hovermode="x unified",
+        xaxis=dict(range=[0, num_carreras]),
+        shapes=[
+            dict(
+                type="line",
+                xref="x", yref="paper",
+                x0=0, y0=0, x1=0, y1=1,
+                line=dict(
+                    color="red",
+                    width=2,
+                    dash="dot",
+                ),
+            )
+        ],
+        annotations=[
+            dict(
+                x=0, y=1.05,
+                xref="x", yref="paper",
+                text="Inicio de la Simulación",
+                showarrow=False,
+                font=dict(
+                    color="red",
+                    size=10
+                ),
+                xanchor="left"
+            )
+        ]
+    )
+
+    plot_accumulated = gr.Plot(fig_accumulated, label="Puntos Acumulados por Piloto")
+
+    return gr.Column(
+        gr.Markdown("## Datos de Pilotos y Visualización de Puntos Acumulados"),
+        data_table,
+        plot_accumulated
+    )
+
+def run_simulation(target_driver, simulation_method, num_sims):
+    # Validaciones básicas
+    if not target_driver:
+        return "Por favor, selecciona un piloto.", None
+    if not simulation_method:
+        return "Por favor, selecciona un método de simulación.", None
+    if num_sims < 1:
+        return "El número de simulaciones debe ser al menos 1.", None
+
+    wins = 0
+    if simulation_method == "Serial":
+        wins = monte_carlo_serial(num_sims, pilotos_data_from_excel, pilotos_nombres_simulacion, num_carreras, target_driver)
+    elif simulation_method == "Serial Optimizado":
+        # Usamos la versión optimizada con NumPy
+        wins = monte_carlo_serial_optimizado(num_sims, pilotos_data_from_excel, pilotos_nombres_simulacion, num_carreras, target_driver)
+    elif simulation_method == "Concurrente":
+        # Advertencia: La concurrencia puede fallar en algunos entornos de HF Spaces.
+        try:
+            wins = monte_carlo_concurrente(num_sims, pilotos_data_from_excel, pilotos_nombres_simulacion, num_carreras, target_driver)
+        except Exception as e:
+            error_msg = f"ERROR: Falló el método Concurrente (multiprocessing). Prueba con 'Serial Optimizado'. Detalle: {e}"
+            return error_msg, None
+    else:
+        return "Método de simulación no válido.", None
+
+    prob = wins / num_sims
+
+    labels = [target_driver + " Gana", "Otros Ganan"]
+    values = [wins, num_sims - wins]
+
+    fig_pie = go.Figure(data=[go.Pie(labels=labels, values=values, hole=.3)])
+    fig_pie.update_layout(
+        title=f"Probabilidad de que {target_driver} sea Campeón",
+        annotations=[dict(text=f'{prob:.2%}', x=0.5, y=0.5, font_size=20, showarrow=False)]
+    )
+
+    result_text = f"Resultados de la simulación para {target_driver} usando el método '{simulation_method}' con {num_sims} simulaciones:\n" \
+                  f"Victorias de {target_driver}: {wins}\n" \
+                  f"Probabilidad de ser campeón: {prob:.4f} ({prob:.2%})"
+
+    return result_text, fig_pie
+
+
+### DEFINIR LOS ESTILOS PARA LA TARJETA CON LA IMAGEN DE FONDO
+# Usamos las variables IMAGEN_PORTADA e IMAGEN_ENCABEZADO que contienen el Base64
+css_style = f"""
+/* ESTILO PARA LA TARJETA DE PORTADA*/
+.f1-background-card {{
+    background-image: url('{IMAGEN_PORTADA}');
+    background-size: cover;
+    background-position: center;
+    background-blend-mode: multiply;
+    background-color: rgba(255, 255, 255, 0.2);
+    border-radius: 15px;
+    box-shadow:
+        8px 8px 15px rgba(0, 0, 0, 0.7),
+        -8px -8px 15px rgba(0, 0, 0, 0.3);
+    padding: 30px;
+    min-height: 500px;
+}}
+
+/* ESTILO PARA LA TARJETA DE ENCABEZADO*/
+.f1-header-card {{
+    background-image: url('{IMAGEN_ENCABEZADO}');
+    background-size: cover;
+    border-radius: 15px;
+    box-shadow:
+        8px 8px 15px rgba(0, 0, 0, 0.7),
+        -8px -8px 15px rgba(0, 0, 0, 0.3);
+    padding: 30px;
+    height: 50px;
+}}
+
+/* ESTILO PARA EL TÍTULO PRINCIPAL */
+.title * {{
+    font-size: 60px !important;
+    text-shadow: 2px 2px 6px rgba(0,0,0,1);
+    line-height: 1.3;
+    color: white !important;
+}}
+
+/* ESTILO PARA EL SUBTÍTULO */
+.subtitle * {{
+    font-size: 30px !important;
+    font-weight: 400;
+    margin-top: 10px;
+    line-height: 1.3;
+    text-shadow: 2px 2px 6px rgba(0,0,0,1);
+    color: white !important;
+}}
+"""
+
+### INTERFAZ GRADIO (Se mantiene la estructura Blocks)
+
+with gr.Blocks(css=css_style) as demo:
+    gr.Row(elem_classes=["f1-header-card"])
+
+    with gr.Tab("Inicio"):
+        with gr.Column(elem_classes=["f1-background-card"]):
+            gr.Markdown("Análisis de Campeón de F1 2025<br>Simulación Monte Carlo",
+                         elem_classes=["title"])
+            gr.Markdown("<br><br><br><br>Esta aplicación simula el campeonato de F1 2025<br>"
+                         "usando diferentes algoritmos de Monte Carlo<br>"
+                         "para predecir la probabilidad de que un piloto sea campeón.",
+                         elem_classes=["subtitle"])
+
+    with gr.Tab("Datos y Visualización"):
+        create_data_viz_tab()
+
+    with gr.Tab("Simulación de Campeonato"):
+        with gr.Row():
+            with gr.Column(scale=1): # Left menu
+                gr.Markdown("### Configuración de la Simulación")
+                driver_dropdown = gr.Dropdown(
+                    choices=pilotos_nombres_simulacion,
+                    value="Lando Norris", # Cambiado a un valor inicial fijo
+                    label="Seleccionar Piloto Objetivo"
+                )
+                method_dropdown = gr.Dropdown(
+                    choices=["Serial", "Serial Optimizado", "Concurrente"],
+                    value="Serial Optimizado",
+                    label="Método de Simulación"
+                )
+                sims_slider = gr.Slider(
+                    minimum=100000,
+                    maximum=1000000,
+                    step=100000,
+                    value=500000,
+                    label="Número de Simulaciones"
+                )
+                run_button = gr.Button("Ejecutar Simulación")
+
+            with gr.Column(scale=2): # Right display area
+                gr.Markdown("### Resultados de la Simulación")
+                simulation_output_text = gr.Textbox(
+                    label="Detalles de la Simulación",
+                    interactive=False,
+                    lines=5
+                )
+                simulation_output_plot = gr.Plot(label="Probabilidad de Campeonato")
+
+        run_button.click(
+            run_simulation,
+            inputs=[driver_dropdown, method_dropdown, sims_slider],
+            outputs=[simulation_output_text, simulation_output_plot]
+        )
+
+# --- MODIFICACIÓN CLAVE 2: ELIMINAR EL PARÁMETRO 'share=True' ---
+# Hugging Face Spaces se encarga del hosting, no necesitamos el túnel de Gradio.
+demo.launch()