app.py

import gradio as gr
import torch
from chronos import ChronosPipeline
import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from sklearn.metrics import mean_absolute_error, mean_squared_error
import tempfile

def get_popular_tickers():
    return [
        "AAPL", "MSFT", "GOOGL", "AMZN", "META", "TSLA", "NVDA", "JPM",
        "JNJ", "V", "PG", "WMT", "BAC", "DIS", "NFLX", "INTC"
    ]

def predict_stock(ticker, train_data_points, prediction_days):
    try:
        # Asegurar que los parámetros sean enteros
        train_data_points = int(train_data_points)
        prediction_days = int(prediction_days)
        
        # Configurar el pipeline
        pipeline = ChronosPipeline.from_pretrained(
            "amazon/chronos-t5-mini",
            device_map="cpu",
            torch_dtype=torch.float32
        )
        
        # Obtener la cantidad máxima de datos disponibles
        stock = yf.Ticker(ticker)
        hist = stock.history(period="max")
        stock_prices = hist[['Close']].reset_index()
        df = stock_prices.rename(columns={'Date': 'Date', 'Close': f'{ticker}_Close'})
        
        total_points = len(df)
        
        # Asegurar que el número de datos de entrenamiento no exceda el total disponible
        train_data_points = min(train_data_points, total_points)
        
        # Crear el contexto para entrenamiento
        context = torch.tensor(df[f'{ticker}_Close'][:train_data_points].values, dtype=torch.float32)
        
        # Realizar predicción
        forecast = pipeline.predict(context, prediction_days, limit_prediction_length=False)
        low, median, high = np.quantile(forecast[0].numpy(), [0.01, 0.5, 0.99], axis=0)
        
        plt.figure(figsize=(20, 10))
        plt.clf()
        
        # Determinar el rango de fechas para mostrar en el gráfico
        context_days = min(10, train_data_points)
        start_index = max(0, train_data_points - context_days)
        end_index = min(train_data_points + prediction_days, total_points)
        
        # Plotear datos históricos incluyendo datos reales después del entrenamiento
        historical_dates = df['Date'][start_index:end_index]
        historical_data = df[f'{ticker}_Close'][start_index:end_index].values
        plt.plot(historical_dates,
                 historical_data,
                 color='blue',
                 linewidth=2,
                 label='Datos Reales')
        
        # Crear fechas para la predicción considerando solo días hábiles
        if train_data_points < total_points:
            # Si hay más datos después del entrenamiento
            prediction_start_date = df['Date'].iloc[train_data_points]
        else:
            # Si estamos en el último punto, generar fechas futuras
            last_date = df['Date'].iloc[-1]
            prediction_start_date = last_date + pd.Timedelta(days=1)
        
        # Generar fechas de predicción solo en días hábiles
        prediction_dates = pd.date_range(start=prediction_start_date, periods=prediction_days, freq='B')
        
        # Plotear predicción
        plt.plot(prediction_dates,
                 median,
                 color='black',
                 linewidth=2,
                 linestyle='-',
                 label='Predicción')
        
        # Área de confianza
        plt.fill_between(prediction_dates, low, high,
                         color='gray', alpha=0.2,
                         label='Intervalo de Confianza')
        
        # Calcular métricas si hay datos reales para comparar
        overlap_end_index = train_data_points + prediction_days
        if overlap_end_index <= total_points:
            real_future_dates = df['Date'][train_data_points:overlap_end_index]
            real_future_data = df[f'{ticker}_Close'][train_data_points:overlap_end_index].values
            
            # Asegurar que las fechas de predicción y las reales coincidan
            matching_dates = real_future_dates[real_future_dates.isin(prediction_dates)]
            matching_indices = matching_dates.index - train_data_points
            plt.plot(matching_dates,
                     real_future_data[matching_indices],
                     color='red',
                     linewidth=2,
                     linestyle='--',
                     label='Datos Reales de Validación')
            
            # Filtrar las predicciones que coinciden con las fechas reales
            predicted_data = median[:len(matching_indices)]
            mae = mean_absolute_error(real_future_data[matching_indices], predicted_data)
            rmse = np.sqrt(mean_squared_error(real_future_data[matching_indices], predicted_data))
            mape = np.mean(np.abs((real_future_data[matching_indices] - predicted_data) / real_future_data[matching_indices])) * 100
            plt.title(f"Predicción del Precio de {ticker}\nMAE: {mae:.2f} | RMSE: {rmse:.2f} | MAPE: {mape:.2f}%",
                      fontsize=14, pad=20)
        else:
            plt.title(f"Predicción Futura del Precio de {ticker}",
                      fontsize=14, pad=20)
        
        plt.legend(loc="upper left", fontsize=12)
        plt.xlabel("Fecha", fontsize=12)
        plt.ylabel("Precio", fontsize=12)
        
        # Habilitar líneas de referencia diarias en el gráfico
        plt.grid(True, which='both', axis='x', linestyle='--', linewidth=0.5)
        
        # Formatear el eje x para mostrar las fechas correctamente y agregar líneas de referencia diarias
        ax = plt.gca()
        locator = mdates.DayLocator()
        formatter = mdates.DateFormatter('%Y-%m-%d')
        ax.xaxis.set_major_locator(locator)
        ax.xaxis.set_major_formatter(formatter)
        
        # Rotar las etiquetas de fecha
        plt.setp(ax.get_xticklabels(), rotation=45, ha='right')
        
        plt.tight_layout()
        
        # Crear un archivo temporal para el CSV
        temp_csv = tempfile.NamedTemporaryFile(delete=False, suffix='.csv')
        prediction_df = pd.DataFrame({
            'Date': prediction_dates,
            'Predicted_Price': median,
            'Lower_Bound': low,
            'Upper_Bound': high
        })
        
        # Agregar datos reales si están disponibles y coinciden con las fechas de predicción
        if overlap_end_index <= total_points:
            real_future_dates = df['Date'][train_data_points:overlap_end_index]
            real_future_data = df[f'{ticker}_Close'][train_data_points:overlap_end_index].values
            matching_dates = real_future_dates[real_future_dates.isin(prediction_dates)]
            prediction_df = prediction_df[prediction_df['Date'].isin(matching_dates)]
            prediction_df['Real_Price'] = real_future_data[:len(prediction_df)]
        
        # Guardar el DataFrame en el archivo temporal
        prediction_df.to_csv(temp_csv.name, index=False)
        temp_csv.close()
        
        # Retornar el gráfico y la ruta del archivo CSV
        return plt, temp_csv.name
            
    except Exception as e:
        print(f"Error: {str(e)}")
        raise gr.Error(f"Error al procesar {ticker}: {str(e)}")

# Crear la interfaz de Gradio
with gr.Blocks() as demo:
    gr.Markdown("# Aplicación de Predicción de Precios de Acciones")
    
    with gr.Row():
        with gr.Column(scale=1):
            ticker = gr.Dropdown(
                choices=get_popular_tickers(),
                label="Selecciona el Símbolo de la Acción"
            )
            train_data_points = gr.Slider(
                minimum=50,
                maximum=5000,
                value=1000,
                step=1,
                label="Número de Datos para Entrenamiento"
            )
            prediction_days = gr.Slider(
                minimum=1,
                maximum=60,
                value=5,
                step=1,
                label="Número de Días a Predecir"
            )
            predict_btn = gr.Button("Predecir")
        
    with gr.Column():
        plot_output = gr.Plot(label="Gráfico de Predicción")
        download_btn = gr.File(label="Descargar Predicciones")
    
    def update_train_data_points(ticker):
        # Actualizar el máximo de puntos de entrenamiento basándose en los datos disponibles
        stock = yf.Ticker(ticker)
        hist = stock.history(period="max")
        total_points = len(hist)
        # Actualizar el deslizador para reflejar el número total de puntos disponibles
        return gr.Slider.update(maximum=total_points, value=min(1000, total_points))
    
    ticker.change(
        fn=update_train_data_points,
        inputs=[ticker],
        outputs=[train_data_points]
    )
    
    predict_btn.click(
        fn=predict_stock,
        inputs=[ticker, train_data_points, prediction_days],
        outputs=[plot_output, download_btn]
    )

demo.launch()