Update app.py

app.py

@@ -15,154 +15,8 @@ def get_popular_tickers():
         "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)}")
+# Resto del código se mantiene igual hasta la sección de la interfaz Gradio
 
-# Crear la interfaz de Gradio
 with gr.Blocks() as demo:
     gr.Markdown("# Aplicación de Predicción de Precios de Acciones")
     
@@ -170,6 +24,7 @@ with gr.Blocks() as demo:
         with gr.Column(scale=1):
             ticker = gr.Dropdown(
                 choices=get_popular_tickers(),
+                value="AAPL",  # Añadido valor por defecto
                 label="Selecciona el Símbolo de la Acción"
             )
             train_data_points = gr.Slider(
@@ -193,12 +48,18 @@ with gr.Blocks() as demo:
         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))
+        try:
+            stock = yf.Ticker(ticker)
+            hist = stock.history(period="max")
+            total_points = len(hist)
+            return gr.Slider.update(
+                maximum=total_points,
+                value=min(1000, total_points),
+                visible=True
+            )
+        except Exception as e:
+            print(f"Error updating slider: {str(e)}")
+            return gr.Slider.update(visible=True)  # Mantener slider visible en caso de error
     
     ticker.change(
         fn=update_train_data_points,
@@ -212,4 +73,4 @@ with gr.Blocks() as demo:
         outputs=[plot_output, download_btn]
     )
 
-demo.launch()
+demo.launch()