Update pages/3_BiLTSM_Прогноз bitcoin.py

pages/3_BiLTSM_Прогноз bitcoin.py

@@ -1,46 +1,36 @@
 import streamlit as st
-import torch
-import torch.nn as nn
-import numpy as np
+import yfinance as yf
 import pandas as pd
+import numpy as np
 import matplotlib.pyplot as plt
-from sklearn.preprocessing import MinMaxScaler
-from datetime import timedelta
-import yfinance as yf
-from model.lstm_model import BiLSTM
+import torch
+import torch.nn as nn
 import torch.optim as optim
+from datetime import date, datetime, timedelta
+from model.lstm_model import BiLSTM
+from sklearn.metrics import mean_squared_error
+from sklearn.preprocessing import MinMaxScaler
+import plotly.graph_objects as go
 
+st.set_page_config(layout='wide', initial_sidebar_state='expanded')
+st.set_option('deprecation.showPyplotGlobalUse', False)
+st.title('ML Wall Street')
+st.image('images/img.png')
 
-# # Загрузка данных для BTC-USD
-# def load_data():
-#     START = "2023-01-01"  # Замените на нужную вам дату начала
-#     TODAY = "2024-01-01"  # Замените на текущую дату или нужную вам дату окончания
-#     btc_usdt = yf.download('BTC-USD', START, TODAY)
-#     btc_usdt.reset_index(inplace=True)
-#     return btc_usdt
+START = "2021-01-01"
+TODAY = date.today().strftime("%Y-%m-%d")
+period = st.slider('Количество дней прогноза:', 1, 14, 14)
 
-# # Загрузка данных для BTC_USDT
-# btc_usdt = load_data()
+df = yf.download('BTC-USD', START, TODAY)
+df.reset_index(inplace=True)
+df['Date'] = pd.to_datetime(df['Date'])  # Преобразование в формат datetime
 
-# Загрузка данных из файла CSV
-data_path = "model/BTC-USD_data.csv"
-btc_usdt = pd.read_csv(data_path)
+latest_date = df['Date'].iloc[-1].strftime('%Y-%m-%d')
+st.markdown(f"<h3 style='text-align: center;'>Цены актуальны на последнюю дату закрытия торгов {latest_date}</h3>", unsafe_allow_html=True)
 
 scaler = MinMaxScaler(feature_range=(0, 1))
-scaled_data = scaler.fit_transform(btc_usdt['Adj Close'].values.reshape(-1, 1))
-
-def rmse(predictions, targets):
-    return np.sqrt(((predictions - targets) ** 2).mean())
-
-def mape(predictions, targets):
-    return np.mean(np.abs((targets - predictions) / targets)) * 100
+scaled_data = scaler.fit_transform(df['Adj Close'].values.reshape(-1, 1))
 
-def weighted_mape(predictions, targets, weights):
-    errors = np.abs(targets - predictions)
-    weighted_errors = errors * weights
-    weighted_mape = np.sum(weighted_errors) / np.sum(np.abs(targets) * weights) * 100
-    return weighted_mape
-    
 def create_dataset(data, time_step=1):
     X, Y = [], []
     for i in range(len(data)-time_step-1):
@@ -49,94 +39,105 @@ def create_dataset(data, time_step=1):
         Y.append(data[i + time_step, 0])
     return np.array(X), np.array(Y)
 
-time_step = 14
-    
-X, y = create_dataset(scaled_data, time_step)
+X, y = create_dataset(scaled_data, time_step=period)
 
 # Разделяем данные на обучающую и тестовую выборки
-test_size = 14  # 14 дней для теста
+test_size = period
 train_size = len(X) - test_size
 X_train, X_test = X[:train_size], X[train_size:]
 y_train, y_test = y[:train_size], y[train_size:]
 
-X_train = torch.Tensor(X_train).unsqueeze(-1)  # Добавляем размерность
-X_test = torch.Tensor(X_test).unsqueeze(-1)    # Для совместимости с LSTM
+X_train = torch.Tensor(X_train).unsqueeze(-1)
+X_test = torch.Tensor(X_test).unsqueeze(-1)
 y_train = torch.Tensor(y_train)
 y_test = torch.Tensor(y_test)
 
-# Загрузка весов модели
-weights_path = "model/model_weights.pth"
 input_size = 1
-hidden_size = 128  # Используем тот же размер, что и при обучении
-num_layers = 3     # Используем тот же размер, что и при обучении
+hidden_size = 128
+num_layers = 3
 output_size = 1
-
-# Создание BiLSTM модели
 model = BiLSTM(input_size, hidden_size, num_layers, output_size)
 criterion = nn.MSELoss()
-optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
+optimizer = optim.Adam(model.parameters(), lr=0.001)
 
-# Загрузка весов
-model.load_state_dict(torch.load(weights_path))
+model.load_state_dict(torch.load('model/model_weights.pth'))
 model.eval()
-
-# Получение предсказаний с помощью загруженной модели
 with torch.no_grad():
     test_predictions = model(X_test)
     test_loss = criterion(test_predictions, y_test.view(-1, 1))
 
-    test_predictions = scaler.inverse_transform(test_predictions.numpy())
-    y_test = scaler.inverse_transform(y_test.numpy().reshape(-1, 1))
-    test_rmse = rmse(test_predictions, y_test)
-    test_mape = mape(test_predictions, y_test)
+    test_predictions = scaler.inverse_transform(test_predictions.cpu().numpy())
+    y_test = scaler.inverse_transform(y_test.view(-1, 1).cpu().numpy())
+    
+    test_rmse = np.sqrt(mean_squared_error(test_predictions, y_test))
+    test_mape = np.mean(np.abs((y_test - test_predictions) / y_test)) * 100
     weights = np.array([1.0, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4])
-    test_weighted_mape = weighted_mape(test_predictions, y_test, weights)
+    test_weighted_mape = np.sum(np.abs(y_test - test_predictions) * weights) / np.sum(np.abs(y_test) * weights) * 100
 
-# Вывод графика и метрик
-st.title("Bitcoin Price Prediction")
-st.write("### Predictions vs Actual (Last 14 Days)")
+    st.write(f'Test RMSE: {test_rmse:.4f}')
+    st.write(f'Test MAPE: {test_mape:.4f}%')
+    st.write(f'Test Weighted MAPE: {test_weighted_mape:.4f}%')
 
-# Генерация предсказаний для будущих дат
-with torch.no_grad():
-    future_predictions = model(X_test)  # Предсказания для тестовой выборки
-    future_predictions = scaler.inverse_transform(future_predictions.numpy())
 
-# Генерация дат для будущих предсказаний
-future_dates = [btc_usdt['Date'].values[-1] + np.timedelta64(i + 1, 'D') for i in range(14)]
-    
-# Преобразование предсказаний для будущих дат в формат DataFrame
-future_df = pd.DataFrame({
-    'Date': future_dates,
-    'Predicted_Price': future_predictions.flatten()
-})
-
-# Вывод графика предсказаний на будущие даты
-st.line_chart(future_df.set_index('Date')['Predicted_Price'], use_container_width=True)
-st.title("Future Bitcoin Price Predictions")
-
-# Вывод метрик по кнопке
-if st.button("Show Metrics"):
-    st.write("### Test Metrics")
-    st.write(f"**Test Loss:** {test_loss.item():.4f}")
-    st.write(f"**Test RMSE:** {test_rmse:.4f}")
-    st.write(f"**Test MAPE:** {test_mape:.4f}%")
-    st.write(f"**Test Weighted MAPE:** {test_weighted_mape:.4f}%")
-# Вывод графика предсказаний на будущие даты
-st.line_chart(future_df.set_index('Date')['Predicted_Price'], use_container_width=True)
-st.title("Future Bitcoin Price Predictions")
-
-# Вывод метрик
-st.write("### Future Predictions (Next 14 Days)")
-st.write(f"**Average Predicted Price:** {future_df['Predicted_Price'].mean():.2f}")
-st.write(f"**Maximum Predicted Price:** {future_df['Predicted_Price'].max():.2f}")
-st.write(f"**Minimum Predicted Price:** {future_df['Predicted_Price'].min():.2f}")
+# Получение дат для будущих предсказаний
+future_dates = pd.date_range(df['Date'].iloc[-1] + timedelta(days=1), periods=14)
 
-# Вывод тренда на первый и последний день
-trend_first_day = future_df['Predicted_Price'].iloc[0] - btc_usdt['Adj Close'].iloc[-1]
-trend_last_day = future_df['Predicted_Price'].iloc[-1] - future_df['Predicted_Price'].iloc[0]
+# Прогнозы с учетом трендов
+trend_first_day = test_predictions[0] - df['Adj Close'].iloc[-1]
+trend_last_day = test_predictions[-1] - test_predictions[0]
+adjusted_future_predictions = [df['Adj Close'].iloc[-1] + trend_first_day + (trend_last_day / 14) * i for i in range(14)]
+
+# Создание графика
+plt.figure(figsize=(12, 6))
+plt.plot(df['Date'], df['Adj Close'], label='Actual', linewidth=2)
+plt.plot(future_dates, adjusted_future_predictions, label='Предсказание на 14 дней', linestyle='--', linewidth=2)
+
+plt.title('Предсказание стоимости Bitcoin на 14 Дней')
+plt.xlabel('Date')
+plt.ylabel('Price')
+plt.xticks(rotation=45)
+plt.legend()
 
-trend_first_day_text = "Growth" if trend_first_day > 0 else "Decline" if trend_first_day < 0 else "No trend"
-trend_last_day_text = "Growth" if trend_last_day > 0 else "Decline" if trend_last_day < 0 else "No trend"
+# Отображение графика в Streamlit
+st.pyplot(plt)
 
-st.write(f"**Trend on the First Day:** {trend_first_day_text}")
-st.write(f"**Trend on the Last Day:** {trend_last_day_text}")
+# Вывод прогнозов
+st.write("Прогноз на 14 дней вперед:")
+for i, (date, pred) in enumerate(zip(future_dates, adjusted_future_predictions)):
+    st.write(f"День {i + 1} ({date}): Прогноз: {float(pred):.2f}")
+
+# Вывод тренда на первый и последний день
+trend_first_day_text = "Рост" if trend_first_day > 0 else "Падение" if trend_first_day < 0 else "Нет тренда"
+trend_last_day_text = "Рост" if trend_last_day > 0 else "Падение" if trend_last_day < 0 else "Нет тренда"
+
+st.write(f"Тренд на первый день: {trend_first_day_text}")
+st.write(f"Тренд на последний день: {trend_last_day_text}")
+
+# Создание графика с использованием Plotly
+fig = go.Figure()
+# График для фактических данных
+fig.add_trace(go.Scatter(x=df['Date'], y=df['Adj Close'], mode='lines', name='Фактические данные', line=dict(width=2)))
+# График для предсказаний на 14 дней
+fig.add_trace(go.Scatter(x=future_dates, y=adjusted_future_predictions, mode='lines', name='Прогноз (14 дней)', line=dict(width=2, dash='dash')))
+
+# Настройки макета графика
+fig.update_layout(
+    title='Прогноз стоимости Bitcoin на следующие 14 дней',
+    xaxis_title='Дата',
+    yaxis_title='Цена',
+    xaxis=dict(tickangle=-45),
+    legend=dict(x=0, y=1, traceorder='normal'),
+    margin=dict(l=0, r=0, t=30, b=0),
+    
+    # range slider
+    xaxis_rangeslider=dict(
+        visible=True,
+        thickness=0.05,  # Толщина слайдера
+        bordercolor='white',  # Цвет границы слайдера
+        bgcolor='rgba(219, 219, 219, 0.25)',  # Цвет фона слайдера
+        range=[df['Date'].iloc[0], future_dates[-1]]  # Обновление диапазона дат
+    )
+)
+
+# Отображение графика
+st.plotly_chart(fig, use_container_width=True)