Upload 9 files

src/Portfolio_optimization.py

@@ -0,0 +1,72 @@
+import streamlit as st
+
+from experiment_runner_for_portfolio import DataLoader, Portfolio
+import pickle
+from sidebar_portfolio import sidebar
+
+
+st.set_page_config(
+    page_title="Portfolio optimization",
+    page_icon="📊")
+
+st.title("Portfolio Optimization")
+sidebar_dict = sidebar()
+run = st.sidebar.button('Run portfolio optimization')
+dataloader = DataLoader()
+portfolio = Portfolio()
+if run:
+    st.header('Price Prediction Results')
+    dataloader.experiment_data(top_n = sidebar_dict['top_n'], num_scale_steps = sidebar_dict['num_scale_steps'],
+                                    scaling_strategy = sidebar_dict['scaling_strategy'], time_step_backward = sidebar_dict['time_step_backward'])
+    #plot_df, metrics_df, models_dict = experiment(ticker = sidebar_dict['ticker'], num_scale_steps= sidebar_dict['num_scale_steps'],
+    #           scaling_strategy= sidebar_dict['scaling_strategy'], time_step_backward= sidebar_dict['time_step_backward'])
+    col1_tickers, col2_tickers = st.columns(2)
+    with col1_tickers:
+        st.subheader('Valid Tickers:')
+        st.write(dataloader.valid_tickers)
+    with col2_tickers:
+        st.subheader('Invalid Tickers:')
+        st.write(dataloader.invalid_tickers)
+    
+    col1_date, col2_date = st.columns(2)
+    with col1_date:
+        st.write('Test Min Date:')
+        st.write(dataloader.global_min_date)
+    with col2_date:
+        st.write('Training Max Date:')
+        st.write(dataloader.global_max_date)
+
+    st.subheader('Model Metrics:')
+    for ticker in dataloader.valid_tickers:
+        st.write(f'{ticker}:')
+        st.write('Best model on test data MAPE: ', dataloader.tickers_dict[ticker]['metrics_df'].T.sort_values(by='Test data MAPE', ascending=True).index[0])
+        st.write(dataloader.tickers_dict[ticker]['metrics_df'])
+        
+    st.header('Portfolio Optimization Results')
+    portfolio.optimize_portfolio(cov_matrix=dataloader.cov_matrix, validation_data=dataloader.validation_data, validation_actual=dataloader.validation_actual, 
+                             test_data=dataloader.test_data, test_actual=dataloader.test_actual, target_return=sidebar_dict['target_return'], allow_short=sidebar_dict['allow_short'])
+    col1_weights, col2_weights = st.columns(2)
+
+    with col1_weights:
+        st.subheader('Selected tickers:')
+        st.write(dataloader.selected_features)
+    with col2_weights:
+        st.subheader('Portfolio weights:')
+        st.write(portfolio.weights)
+
+
+    col1_results, col2_results = st.columns(2)
+    with col1_results:
+        st.write(f"Validation Return Accuracy: {portfolio.val_return_accuracy:.4f}")
+        st.write(f"Validation Volatility Accuracy: {portfolio.val_volatility_accuracy:.4f}")
+        st.write(f"Validation Sharpe Ratio Deviation: {portfolio.val_sharpe_deviation:.4f}")
+        st.write(f"Validation Pred Return Sum: {portfolio.val_sum_pred_returns:.4f}")
+        st.write(f"Validation Actual Return Sum: {portfolio.val_sum_realized_returns:.4f}")
+
+    with col2_results:
+        st.write(f"Test Return Accuracy: {portfolio.test_return_accuracy:.4f}")
+        st.write(f"Test Volatility Accuracy: {portfolio.test_volatility_accuracy:.4f}")
+        st.write(f"Test Sharpe Ratio Deviation: {portfolio.test_sharpe_deviation:.4f}")
+        st.write(f"Test Pred Return Sum: {portfolio.test_sum_pred_returns:.4f}")
+        st.write(f"Test Actual Return Sum: {portfolio.test_sum_realized_returns:.4f}")
+

src/README.md

@@ -0,0 +1 @@
+# ForecastAGLT

src/experiment_runner_for_best_models.py

@@ -0,0 +1,568 @@
+
+
+def experiment(ticker, num_scale_steps, scaling_strategy, time_step_backward):
+    import pandas as pd
+    import numpy as np
+    import math
+
+    # For Evalution we will use these library
+
+    from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score, mean_absolute_percentage_error
+    from sklearn.preprocessing import MinMaxScaler
+
+    # For model building we will use these library
+
+    from tensorflow.keras.models import Sequential
+    from tensorflow.keras.layers import Dense
+    from tensorflow.keras.layers import LSTM
+    from tensorflow.keras import initializers
+    from tensorflow.keras.callbacks import EarlyStopping
+
+    # For PLotting we will use these library
+    import matplotlib.pyplot as plt
+
+    import yfinance as yf
+
+    from gmdh import CriterionType, Criterion, Multi, Combi, Mia, Ria, PolynomialType
+    from chronos import ChronosPipeline
+    import torch
+    import pmdarima as pm
+    from pages.utils.utils import create_dataset, make_prediction
+    # @st.cache_data
+    def get_pipeline():
+        pipeline = ChronosPipeline.from_pretrained(
+            "amazon/chronos-t5-tiny",
+            device_map="cpu",  # use "cpu" for CPU inference and "mps" for Apple Silicon
+            torch_dtype=torch.bfloat16)
+        return pipeline
+
+    pipeline = get_pipeline()
+
+    pd.options.display.float_format = '{:20,.4f}'.format
+    seed = 42
+    #tickers = ['BTC', 'ETH', 'BNB',
+    #            'XRP', 'STETH','ADA','DOGE',
+    #           'WTRX','LTC','SOL','TRX','DOT','MATIC','BCH','WBTC','TON11419',
+    #           'DAI','SHIB','AVAX','BUSD','LEO','LINK']
+    #intervals = ['1d', '1wk', '1mo']
+    #ticker = 'BTC' #st.selectbox("Ticker", options=tickers)
+    interval = '1d' #st.selectbox("Interval", options = intervals)
+
+    int_to_periods = {'1m':'5d', '2m':'1mo', '5m': '1mo','15m': '1mo','30m': '1mo','60m': '1mo','90m': '1mo',
+               '1h': '1y','1d': '10y','5d': '10y','1wk': '10y','1mo': '10y','3mo': '10y'}
+
+    period_cut = {'1d': '2022-02-19', '1wk': '2020-06-19', '1mo': '2014-06-19'}
+
+    try:
+        maindf = yf.download(tickers = f"{ticker}-USD",  # list of tickers
+                    period = 'max', #int_to_periods[interval],         # time period
+                    interval = interval,       # trading interval
+                    prepost = False,       # download pre/post market hours data?
+                    repair = True,)         # repair obvious price errors e.g. 100x?
+        if len(maindf) == 0:
+            raise FileNotFoundError
+    except:
+        maindf = pd.read_csv(f'{ticker}.csv')
+    #maindf = yf.download('BTC-USD',start, end, auto_adjust=True)#['Close']
+    maindf=maindf.reset_index()
+    maindf['Date'] = pd.to_datetime(maindf['Date'], format='%Y-%m-%d')
+
+    #maindf = pd.read_csv('BTC-USD.csv')
+    print('Total number of days present in the dataset: ',maindf.shape[0])
+    print('Total number of fields present in the dataset: ',maindf.shape[1])
+    print(maindf.head())
+
+    y_overall = maindf.copy()
+    #scaling_strategy_list = ['median', 'average', 'undersampling']
+    #scale_step_type_list = ['D','W','M','Y']
+    scale_step_type = 'D'
+    #num_scale_steps = 1
+    #scaling_strategy == 'average'
+    y_overall = y_overall[['Date','Close']]
+    if num_scale_steps > 1:
+        #scaling_expander.selectbox('Метод масштабирования', scaling_strategy_list)
+        scaling_step_combined = str(num_scale_steps) + scale_step_type
+        # Определяем сегодняшнюю дату
+        today = pd.Timestamp.now().normalize()
+        if scaling_strategy == 'average':
+            # y_overall = y_overall.groupby(pd.Grouper(key = 'Date', freq = scaling_step_combined)).mean()
+            # Добавляем колонку для конца интервала
+            y_overall['Interval_End'] = today - (
+                        (today - y_overall['Date']) // pd.Timedelta(scaling_step_combined)) * pd.Timedelta(
+                scaling_step_combined)
+            # Группируем по интервалам и считаем среднее
+            y_overall = y_overall.groupby('Interval_End')['Close'].mean().reset_index()
+            # Сортируем результат
+            y_overall = y_overall.sort_values('Interval_End')  # .reset_index(drop=True)
+            y_overall = y_overall.rename({'Interval_End': 'Date'}, axis=1)
+        elif scaling_strategy == 'median':
+            # y_overall = y_overall.groupby(pd.Grouper(key = 'Date', freq = scaling_step_combined)).median()
+            # y_overall = y_overall.groupby(pd.Grouper(key = 'Date', freq = scaling_step_combined)).mean()
+            # Добавляем колонку для конца интервала
+            y_overall['Interval_End'] = today - (
+                        (today - y_overall['Date']) // pd.Timedelta(scaling_step_combined)) * pd.Timedelta(
+                scaling_step_combined)
+            # Группируем по интервалам и считаем среднее
+            y_overall = y_overall.groupby('Interval_End')['Close'].median().reset_index()
+            # Сортируем результат
+            y_overall = y_overall.sort_values('Interval_End')  # .reset_index(drop=True)
+            y_overall = y_overall.rename({'Interval_End': 'Date'}, axis=1)
+        else:
+            # y_overall = y_overall.resample(on = 'Date', rule = scaling_step_combined).last()
+            # Устанавливаем 'Date' как индекс, если это ещё не сделано
+            # y_overall = y_overall.set_index('Date')
+            # y_overall.columns = y_overall.columns.droplevel(1)
+            y_overall = y_overall.resample(on='Date', rule=scaling_step_combined, origin='end').last()
+            y_overall = y_overall.reset_index()
+
+
+    #names = cycle(['Stock Open Price','Stock Close Price','Stock High Price','Stock Low Price'])
+    fig, ax = plt.subplots()
+    ax.plot(y_overall['Close'], label = 'Stock Close Price')
+    ax.legend()
+    ax.set_title(f'Динамика цены закрытия для {ticker}')
+
+
+    #st.pyplot(fig)
+    #ax.plot()
+
+    #time_step_backward = 15 #st.sidebar.slider('Количество шагов назад для предикторов', 5, 60, 15)
+    time_step_forward = 1 #st.sidebar.slider('Количество шагов вперед для таргета', 1, 60, 1)
+
+
+    pred_days = 1
+    recursive_pred = False
+    if time_step_forward == 1:
+        #expander = st.sidebar.expander('Режим ресурсивного прогноза')
+        pred_days = 15 #expander.slider('Количество шагов для ресурсивного прогноза', 1, 30, 15)
+        recursive_pred = True #expander.checkbox('Запустить рекурсивный прогноз')
+
+
+
+    GMDH = True #st.sidebar.checkbox('Добавить режим МГУА')
+    transformer = True #st.sidebar.checkbox('Добавить режим Transformer')
+    if GMDH:
+        #expander1 = st.sidebar.expander('Гиперпараметры МГУА')
+        GMDHs = {'Combi': Combi(), 'Multi': Multi(), 'Mia': Mia(), 'Ria': Ria()}
+        criterions = {'Критерий регулярности (несимметричная форма)': CriterionType.REGULARITY,
+                      'Критерий регулярности (симметричная форма)': CriterionType.SYM_REGULARITY,
+                      'Критерий стабильности (несимметричная форма)': CriterionType.STABILITY,
+                      'Критерий стабильности (симметричная форма)': CriterionType.SYM_STABILITY,
+                      'Критерий минимума смещения коэффициентов': CriterionType.UNBIASED_COEFFS,
+                      'Критерий минимума смещения решений (несимметричная форма)': CriterionType.UNBIASED_OUTPUTS,
+                      'Критерий минимума смещения решений (симметричная форма)': CriterionType.SYM_UNBIASED_OUTPUTS,
+                      'Абсолютно помехоустойчивый критерий (несимметричная форма)': CriterionType.ABSOLUTE_NOISE_IMMUNITY,
+                      'Абсолютно помехоустойчивый критерий (симметричная форма)': CriterionType.SYM_ABSOLUTE_NOISE_IMMUNITY}
+        polynoms = {'LINEAR': PolynomialType.LINEAR,
+                      'LINEAR_COV': PolynomialType.LINEAR_COV,
+                      'QUADRATIC': PolynomialType.QUADRATIC}
+        GMDH_algo1 = 'Multi' #expander1.selectbox("Алгоритм МГУА", options = GMDHs.keys())
+        criterion1 = 'Критерий регулярности (несимметричная форма)' #expander1.selectbox("Внешний критерий", options = criterions.keys())
+        p_average1 = 1 #expander1.slider('p_average', 1, 10, 1)
+        limit1 = 0. #expander1.number_input('limit', value = 0.)
+        k_best1 = 1 #expander1.slider('k_best', 1, 10, 3 if GMDH_algo == 'Mia' else 1)
+        polynom1 = 'LINEAR' #expander1.selectbox("Вид базовых полиномов", options = polynoms.keys())
+        GMDH_algo2 = 'Ria' #expander1.selectbox("Алгоритм МГУА", options = GMDHs.keys())
+        criterion2 = 'Критерий регулярности (несимметричная форма)' #expander1.selectbox("Внешний критерий", options = criterions.keys())
+        p_average2 = 1 #expander1.slider('p_average', 1, 10, 1)
+        limit2 = 0. #expander1.number_input('limit', value = 0.)
+        k_best2 = 3 #expander1.slider('k_best', 1, 10, 3 if GMDH_algo == 'Mia' else 1)
+        polynom2 = 'QUADRATIC' #expander1.selectbox("Вид базовых полиномов", options = polynoms.keys())
+
+    y_overall.columns = y_overall.columns.droplevel(1)#.droplevel()
+    #y_overall = y_overall.reset_index()
+
+    #if run:
+    # my_bar = st.progress(0, text='Model training progress. Truncating the dataset now')
+    # Lets First Take all the Close Price
+    closedf = y_overall[['Date', 'Close']].dropna()  # maindf[['Date', 'Close']]
+    print("Shape of close dataframe:", closedf.shape)
+    closedf = closedf[-1000:]  # closedf[closedf['Date'] > period_cut[interval]]
+    close_stock = closedf.copy()
+    print("Total data for prediction: ", closedf.shape[0])
+    # my_bar.progress(10 + 1, text='Truncated the dataset -> Scaling it')
+    # deleting date column and normalizing using MinMax Scaler
+
+    scaler = MinMaxScaler(feature_range=(0, 1))
+    # closedf = scaler.fit_transform(np.array(closedf).reshape(-1, 1))
+    print(closedf.shape)
+
+    # my_bar.progress(20 + 1, text='Scaled the dataset -> Splitting it into subsamples')
+    # we keep the training set as 60% and 40% testing set
+
+    training_size = int(len(closedf) * 0.70)
+    test_size = len(closedf) - training_size
+    assert test_size > 2*(time_step_backward + time_step_forward), "Test_size is shorter than 2 x time_step_backward + time_step_forward"
+    train_data, test_data = closedf[0:training_size], closedf[training_size:len(closedf)]
+    train_start_date, train_end_date = train_data['Date'].iloc[0], train_data['Date'].iloc[
+        -1]  # TO BE ADDED TO PY FILE!!!
+
+    del closedf['Date'], train_data['Date'], test_data['Date']  # TO BE ADDED TO PY FILE!!!
+    train_data = scaler.fit_transform(train_data)
+    test_data = scaler.transform(test_data)
+    print("train_data: ", train_data.shape)
+    print("test_data: ", test_data.shape)
+
+    # my_bar.progress(30 + 1, text='Split it into subsamples -> Cutting them into observations')
+
+    X_train, y_train = create_dataset(train_data, time_step_backward, time_step_forward)
+    X_test, y_test = create_dataset(test_data, time_step_backward, time_step_forward)
+
+    print("X_train: ", X_train.shape)
+    print("y_train: ", y_train.shape)
+    print("X_test: ", X_test.shape)
+    print("y_test", y_test.shape)
+
+    # reshape input to be [samples, time steps, features] which is required for LSTM
+    X_train_gmdh = X_train.copy()
+    X_test_gmdh = X_test.copy()
+    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
+    X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)
+
+    print("X_train: ", X_train.shape)
+    print("X_test: ", X_test.shape)
+
+    # my_bar.progress(40 + 1, text='Cut it into observations -> Training the model')
+    model = Sequential()
+    model.add(LSTM(10, input_shape=(None, 1), activation="relu",
+                   kernel_initializer=initializers.GlorotNormal(seed=seed),
+                   bias_initializer=initializers.GlorotNormal(seed=seed)))
+    model.add(Dense(1,
+                    kernel_initializer=initializers.GlorotNormal(seed=seed),
+                    bias_initializer=initializers.GlorotNormal(seed=seed)))
+    model.compile(loss="mean_squared_error", optimizer="adam")
+    callback = EarlyStopping(monitor='loss', patience=30, restore_best_weights=True)
+    history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=100, batch_size=32, verbose=False,
+                        callbacks=[callback])
+
+    arima_model = pm.auto_arima(train_data,
+                                m=12,  # frequency of series
+                                seasonal=True,  # TRUE if seasonal series
+                                d=None,  # let model determine 'd'
+                                test='adf',  # use adftest to find optimal 'd'
+                                start_p=0, start_q=0,  # minimum p and q
+                                max_p=time_step_backward, max_q=time_step_backward,  # maximum p and q
+                                D=None,  # let model determine 'D'
+                                trace=True,
+                                error_action='ignore',
+                                suppress_warnings=True,
+                                stepwise=True)
+    # st.text(arima_model.summary())
+    print(arima_model.summary())
+
+    if GMDH:
+        model_gmdh1 = GMDHs[GMDH_algo1]
+        if GMDH_algo1 == 'Combi':
+            model_gmdh1.fit(X_train_gmdh, y_train, p_average=p_average1, limit=limit1, test_size=0.3,
+                           criterion=Criterion(criterion_type=criterions[criterion1]))
+        if GMDH_algo1 == 'Multi':
+            model_gmdh1.fit(X_train_gmdh, y_train, p_average=p_average1, limit=limit1, test_size=0.3,
+                           criterion=Criterion(criterion_type=criterions[criterion1]),
+                           k_best=k_best1)
+        if GMDH_algo1 in ['Ria', 'Mia']:
+            model_gmdh1.fit(X_train_gmdh, y_train, p_average=p_average1, limit=limit1, test_size=0.3,
+                           criterion=Criterion(criterion_type=criterions[criterion1]),
+                           k_best=k_best1, polynomial_type=polynoms[polynom1])
+        # st.write(f"GMDH model: {model_gmdh.get_best_polynomial()}")
+        print(f"GMDH model 1: {model_gmdh1.get_best_polynomial()}")
+
+        model_gmdh2 = GMDHs[GMDH_algo2]
+        if GMDH_algo2 == 'Combi':
+            model_gmdh2.fit(X_train_gmdh, y_train, p_average=p_average2, limit=limit2, test_size=0.3,
+                           criterion=Criterion(criterion_type=criterions[criterion2]))
+        if GMDH_algo2 == 'Multi':
+            model_gmdh2.fit(X_train_gmdh, y_train, p_average=p_average2, limit=limit2, test_size=0.3,
+                           criterion=Criterion(criterion_type=criterions[criterion2]),
+                           k_best=k_best2)
+        if GMDH_algo2 in ['Ria', 'Mia']:
+            model_gmdh2.fit(X_train_gmdh, y_train, p_average=p_average2, limit=limit2, test_size=0.3,
+                           criterion=Criterion(criterion_type=criterions[criterion2]),
+                           k_best=k_best2, polynomial_type=polynoms[polynom1])
+        # st.write(f"GMDH model: {model_gmdh.get_best_polynomial()}")
+        print(f"GMDH model 2: {model_gmdh2.get_best_polynomial()}")
+    """
+    if transformer:
+        X_train_context = torch.tensor(X_train_gmdh)
+        X_test_context = torch.tensor(X_test_gmdh)
+        X_train_forecast = pipeline.predict(
+            X_train_context,
+            time_step_forward,
+            num_samples=3,
+            temperature=1.0,
+            top_k=50,
+            top_p=1.0)
+        X_test_forecast = pipeline.predict(
+            X_test_context,
+            time_step_forward,
+            num_samples=3,
+            temperature=1.0,
+            top_k=50,
+            top_p=1.0)
+    """
+
+    # my_bar.progress(70 + 1, text='Trained model -> Calculating loss')
+    import matplotlib.pyplot as plt
+
+    loss = history.history['loss']
+    val_loss = history.history['val_loss']
+
+    epochs = range(len(loss))
+
+    fig, ax = plt.subplots()
+    ax.plot(epochs, loss, 'r', label='Training loss')
+    ax.plot(epochs, val_loss, 'b', label='Validation loss')
+    ax.legend()
+    ax.set_title('Потери на обучении и валидации')
+
+    # st.pyplot(fig)
+    ax.plot()
+    # my_bar.progress(80 + 1, text='Calculated loss -> Scoring the dataset')
+
+    original_ytrain = scaler.inverse_transform(y_train.reshape(-1, 1))
+    original_ytest = scaler.inverse_transform(y_test.reshape(-1, 1))
+
+    train_predict, test_predict = make_prediction(X_train, X_test, method='LSTM', model=model,
+                                                  scaler=scaler, time_step_forward=time_step_forward)
+    train_predict_arima, test_predict_arima = make_prediction(X_train, X_test, method='SARIMA', model=arima_model,
+                                                              scaler=scaler, time_step_forward=time_step_forward)
+    if GMDH:
+        train_predict_gmdh1, test_predict_gmdh1 = make_prediction(X_train_gmdh, X_test_gmdh, method='GMDH',
+                                                                model=model_gmdh1,
+                                                                scaler=scaler, time_step_forward=time_step_forward)
+        train_predict_gmdh2, test_predict_gmdh2 = make_prediction(X_train_gmdh, X_test_gmdh, method='GMDH',
+                                                                model=model_gmdh2,
+                                                                scaler=scaler, time_step_forward=time_step_forward)
+    if transformer:
+        X_train_forecast_median, X_test_forecast_median = make_prediction(X_train_gmdh, X_test_gmdh,
+                                                                          method='Transformer', model=pipeline,
+                                                                          scaler=scaler,
+                                                                          time_step_forward=time_step_forward)
+
+    # Evaluation metrices RMSE and MAE
+    metrics_tmp = {}
+    metrics1 = {}
+    metrics1['LSTM'] = []
+    metrics_tmp["Train data RMSE"] = math.sqrt(mean_squared_error(original_ytrain, train_predict))
+    metrics_tmp["Train data MSE"] = mean_squared_error(original_ytrain, train_predict)
+    metrics_tmp["Train data MAE"] = mean_absolute_error(original_ytrain, train_predict)
+    metrics_tmp["Train data MAPE"] = mean_absolute_percentage_error(original_ytrain, train_predict)
+    print("-------------------------------------------------------------------------------------")
+    metrics_tmp["Test data RMSE"] = math.sqrt(mean_squared_error(original_ytest, test_predict))
+    metrics_tmp["Test data MSE"] = mean_squared_error(original_ytest, test_predict)
+    metrics_tmp["Test data MAE"] = mean_absolute_error(original_ytest, test_predict)
+    metrics_tmp["Test data MAPE"] = mean_absolute_percentage_error(original_ytest, test_predict)
+    metrics_tmp["Train data R2 score"] = r2_score(original_ytrain, train_predict)
+    metrics_tmp["Test data R2 score"] = r2_score(original_ytest, test_predict)
+    for metric in metrics_tmp:
+        print(metric, ': ', metrics_tmp[metric])
+        metrics1['LSTM'].append(metrics_tmp[metric])
+
+    metrics1['SARIMA'] = []
+    metrics_tmp["Train data RMSE"] = math.sqrt(mean_squared_error(original_ytrain, train_predict_arima))
+    metrics_tmp["Train data MSE"] = mean_squared_error(original_ytrain, train_predict_arima)
+    metrics_tmp["Train data MAE"] = mean_absolute_error(original_ytrain, train_predict_arima)
+    metrics_tmp["Train data MAPE"] = mean_absolute_percentage_error(original_ytrain, train_predict_arima)
+    print("-------------------------------------------------------------------------------------")
+    metrics_tmp["Test data RMSE"] = math.sqrt(mean_squared_error(original_ytest, test_predict_arima))
+    metrics_tmp["Test data MSE"] = mean_squared_error(original_ytest, test_predict_arima)
+    metrics_tmp["Test data MAE"] = mean_absolute_error(original_ytest, test_predict_arima)
+    metrics_tmp["Test data MAPE"] = mean_absolute_percentage_error(original_ytest, test_predict_arima)
+    metrics_tmp["Train data R2 score"] = r2_score(original_ytrain, train_predict_arima)
+    metrics_tmp["Test data R2 score"] = r2_score(original_ytest, test_predict_arima)
+    for metric in metrics_tmp:
+        print(metric, ': ', metrics_tmp[metric])
+        metrics1['SARIMA'].append(metrics_tmp[metric])
+    if GMDH:
+        metrics1['GMDH_1'] = []
+        metrics_tmp["Train data RMSE"] = math.sqrt(mean_squared_error(original_ytrain, train_predict_gmdh1))
+        metrics_tmp["Train data MSE"] = mean_squared_error(original_ytrain, train_predict_gmdh1)
+        metrics_tmp["Train data MAE"] = mean_absolute_error(original_ytrain, train_predict_gmdh1)
+        metrics_tmp["Train data MAPE"] = mean_absolute_percentage_error(original_ytrain, train_predict_gmdh1)
+        print("-------------------------------------------------------------------------------------")
+        metrics_tmp["Test data RMSE"] = math.sqrt(mean_squared_error(original_ytest, test_predict_gmdh1))
+        metrics_tmp["Test data MSE"] = mean_squared_error(original_ytest, test_predict_gmdh1)
+        metrics_tmp["Test data MAE"] = mean_absolute_error(original_ytest, test_predict_gmdh1)
+        metrics_tmp["Test data MAPE"] = mean_absolute_percentage_error(original_ytest, test_predict_gmdh1)
+        metrics_tmp["Train data R2 score"] = r2_score(original_ytrain, train_predict_gmdh1)
+        metrics_tmp["Test data R2 score"] = r2_score(original_ytest, test_predict_gmdh1)
+        for metric in metrics_tmp:
+            print(metric, ': ', metrics_tmp[metric])
+            metrics1['GMDH_1'].append(metrics_tmp[metric])
+
+        metrics1['GMDH_2'] = []
+        metrics_tmp["Train data RMSE"] = math.sqrt(mean_squared_error(original_ytrain, train_predict_gmdh2))
+        metrics_tmp["Train data MSE"] = mean_squared_error(original_ytrain, train_predict_gmdh2)
+        metrics_tmp["Train data MAE"] = mean_absolute_error(original_ytrain, train_predict_gmdh2)
+        metrics_tmp["Train data MAPE"] = mean_absolute_percentage_error(original_ytrain, train_predict_gmdh2)
+        print("-------------------------------------------------------------------------------------")
+        metrics_tmp["Test data RMSE"] = math.sqrt(mean_squared_error(original_ytest, test_predict_gmdh2))
+        metrics_tmp["Test data MSE"] = mean_squared_error(original_ytest, test_predict_gmdh2)
+        metrics_tmp["Test data MAE"] = mean_absolute_error(original_ytest, test_predict_gmdh2)
+        metrics_tmp["Test data MAPE"] = mean_absolute_percentage_error(original_ytest, test_predict_gmdh2)
+        metrics_tmp["Train data R2 score"] = r2_score(original_ytrain, train_predict_gmdh2)
+        metrics_tmp["Test data R2 score"] = r2_score(original_ytest, test_predict_gmdh2)
+        for metric in metrics_tmp:
+            print(metric, ': ', metrics_tmp[metric])
+            metrics1['GMDH_2'].append(metrics_tmp[metric])
+
+    if transformer:
+        metrics1['Transformer'] = []
+        metrics_tmp["Train data RMSE"] = math.sqrt(mean_squared_error(original_ytrain, X_train_forecast_median))
+        metrics_tmp["Train data MSE"] = mean_squared_error(original_ytrain, X_train_forecast_median)
+        metrics_tmp["Train data MAE"] = mean_absolute_error(original_ytrain, X_train_forecast_median)
+        metrics_tmp["Train data MAPE"] = mean_absolute_percentage_error(original_ytrain, X_train_forecast_median)
+        print("-------------------------------------------------------------------------------------")
+        metrics_tmp["Test data RMSE"] = math.sqrt(mean_squared_error(original_ytest, X_test_forecast_median))
+        metrics_tmp["Test data MSE"] = mean_squared_error(original_ytest, X_test_forecast_median)
+        metrics_tmp["Test data MAE"] = mean_absolute_error(original_ytest, X_test_forecast_median)
+        metrics_tmp["Test data MAPE"] = mean_absolute_percentage_error(original_ytest, X_test_forecast_median)
+        metrics_tmp["Train data R2 score"] = r2_score(original_ytrain, X_train_forecast_median)
+        metrics_tmp["Test data R2 score"] = r2_score(original_ytest, X_test_forecast_median)
+        for metric in metrics_tmp:
+            print(metric, ': ', metrics_tmp[metric])
+            metrics1['Transformer'].append(metrics_tmp[metric])
+
+    metrics_df = pd.DataFrame.from_dict(metrics1, orient='columns')  # (metrics, columns = ['LSTM', 'GMDH'])
+    metrics_df.index = metrics_tmp.keys()
+    # st.write(metrics_df)
+    metrics_df.round(3)
+    print(metrics_df)
+    # my_bar.progress(90 + 1, text='Calculated performance metrics -> Plotting predictions')
+
+    # shift train predictions for plotting
+
+    lag = time_step_backward + (time_step_forward - 1)
+    trainPredictPlot_arima = np.empty_like(closedf)
+    trainPredictPlot_arima[:, :] = np.nan
+    trainPredictPlot_arima[lag:len(train_predict_arima) + lag, :] = train_predict_arima
+    print(trainPredictPlot_arima[lag:len(train_predict_arima) + lag, :].shape, train_predict_arima.shape)
+    print("Train predicted data: ", trainPredictPlot_arima.shape)
+
+    # shift test predictions for plotting
+    testPredictPlot_arima = np.empty_like(closedf)
+    testPredictPlot_arima[:, :] = np.nan
+    testPredictPlot_arima[len(train_predict_arima) + (lag * 2):len(closedf), :] = test_predict_arima
+    print(testPredictPlot_arima[len(train_predict_arima) + (lag * 2):len(closedf), :].shape, test_predict_arima.shape)
+    print("Test predicted data: ", testPredictPlot_arima.shape)
+
+    # lag = time_step_backward + (time_step_forward - 1)
+    trainPredictPlot = np.empty_like(closedf)
+    trainPredictPlot[:, :] = np.nan
+    trainPredictPlot[lag:len(train_predict) + lag, :] = train_predict
+    print(trainPredictPlot[lag:len(train_predict) + lag, :].shape, train_predict.shape)
+    print("Train predicted data: ", trainPredictPlot.shape)
+
+    # shift test predictions for plotting
+    testPredictPlot = np.empty_like(closedf)
+    testPredictPlot[:, :] = np.nan
+    testPredictPlot[len(train_predict) + (lag * 2):len(closedf), :] = test_predict
+    print(testPredictPlot[len(train_predict) + (lag * 2):len(closedf), :].shape, test_predict.shape)
+    print("Test predicted data: ", testPredictPlot.shape)
+
+    if GMDH:
+        trainPredictPlot_gmdh1 = np.empty_like(closedf)
+        trainPredictPlot_gmdh1[:, :] = np.nan
+        trainPredictPlot_gmdh1[lag:len(train_predict_gmdh1) + lag, :] = train_predict_gmdh1
+        print(trainPredictPlot_gmdh1[lag:len(train_predict_gmdh1) + lag, :].shape, train_predict_gmdh1.shape)
+
+        testPredictPlot_gmdh1 = np.empty_like(closedf)
+        testPredictPlot_gmdh1[:, :] = np.nan
+        testPredictPlot_gmdh1[len(train_predict_gmdh1) + (lag * 2):len(closedf), :] = test_predict_gmdh1
+        print(testPredictPlot_gmdh1[len(train_predict_gmdh1) + (lag * 2):len(closedf), :].shape, test_predict_gmdh1.shape)
+
+
+        trainPredictPlot_gmdh2 = np.empty_like(closedf)
+        trainPredictPlot_gmdh2[:, :] = np.nan
+        trainPredictPlot_gmdh2[lag:len(train_predict_gmdh2) + lag, :] = train_predict_gmdh2
+        print(trainPredictPlot_gmdh2[lag:len(train_predict_gmdh2) + lag, :].shape, train_predict_gmdh2.shape)
+
+        testPredictPlot_gmdh2 = np.empty_like(closedf)
+        testPredictPlot_gmdh2[:, :] = np.nan
+        testPredictPlot_gmdh2[len(train_predict_gmdh2) + (lag * 2):len(closedf), :] = test_predict_gmdh2
+        print(testPredictPlot_gmdh2[len(train_predict_gmdh2) + (lag * 2):len(closedf), :].shape, test_predict_gmdh2.shape)
+
+    if transformer:
+        trainPredictPlot_transformer = np.empty_like(closedf)
+        trainPredictPlot_transformer[:, :] = np.nan
+        trainPredictPlot_transformer[lag:len(X_train_forecast_median) + lag, :] = X_train_forecast_median
+        print(trainPredictPlot_transformer[lag:len(X_train_forecast_median) + lag, :].shape,
+              X_train_forecast_median.shape)
+
+        testPredictPlot_transformer = np.empty_like(closedf)
+        testPredictPlot_transformer[:, :] = np.nan
+        testPredictPlot_transformer[len(X_train_forecast_median) + (lag * 2):len(closedf), :] = X_test_forecast_median
+        print(testPredictPlot_transformer[len(X_train_forecast_median) + (lag * 2):len(closedf), :].shape,
+              X_test_forecast_median.shape)
+
+    if GMDH:
+        if transformer:
+            plotdf = pd.DataFrame({'date': close_stock['Date'],
+                                   'original_close': close_stock['Close'],
+                                   'train_predicted_close_arima': trainPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_arima': testPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close': trainPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close': testPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close_gmdh_1': trainPredictPlot_gmdh1.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_gmdh_1': testPredictPlot_gmdh1.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close_gmdh_2': trainPredictPlot_gmdh2.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_gmdh_2': testPredictPlot_gmdh2.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close_transformer': trainPredictPlot_transformer.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_transformer': testPredictPlot_transformer.reshape(1, -1)[0].tolist()})
+        elif not transformer:
+            plotdf = pd.DataFrame({'date': close_stock['Date'],
+                                   'original_close': close_stock['Close'],
+                                   'train_predicted_close_arima': trainPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_arima': testPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close': trainPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close': testPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close_gmdh_1': trainPredictPlot_gmdh1.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_gmdh_1': testPredictPlot_gmdh1.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close_gmdh_2': trainPredictPlot_gmdh2.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_gmdh_2': testPredictPlot_gmdh2.reshape(1, -1)[0].tolist()})
+    elif not GMDH:
+        if transformer:
+            plotdf = pd.DataFrame({'date': close_stock['Date'],
+                                   'original_close': close_stock['Close'],
+                                   'train_predicted_close_arima': trainPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_arima': testPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close': trainPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close': testPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close_transformer': trainPredictPlot_transformer.reshape(1, -1)[
+                                       0].tolist(),
+                                   'test_predicted_close_transformer': testPredictPlot_transformer.reshape(1, -1)[
+                                       0].tolist()})
+        else:
+            plotdf = pd.DataFrame({'date': close_stock['Date'],
+                                   'original_close': close_stock['Close'],
+                                   'train_predicted_close_arima': trainPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_arima': testPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close': trainPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close': testPredictPlot.reshape(1, -1)[0].tolist()})
+    fig, ax = plt.subplots()
+    ax.plot(plotdf['date'], plotdf['original_close'], label='Оригинальная цена закрытия')
+    ax.plot(plotdf['date'], plotdf['train_predicted_close_arima'],
+            label='Предсказанная цена закрытия на тренировке SARIMA')
+    ax.plot(plotdf['date'], plotdf['test_predicted_close_arima'], label='Предсказанная цена закрытия на тесте SARIMA')
+    ax.plot(plotdf['date'], plotdf['train_predicted_close'], label='Предсказанная цена закрытия на тренировке')
+    ax.plot(plotdf['date'], plotdf['test_predicted_close'], label='Предсказанная цена закрытия на тесте')
+    if GMDH:
+        ax.plot(plotdf['date'], plotdf['train_predicted_close_gmdh_1'],
+                label='Предсказанная цена закрытия на тренировке GMDH_1')
+        ax.plot(plotdf['date'], plotdf['test_predicted_close_gmdh_1'], label='Предсказанная цена закрытия на тесте GMDH_1')
+
+        ax.plot(plotdf['date'], plotdf['train_predicted_close_gmdh_2'],
+                label='Предсказанная цена закрытия на тренировке GMDH_2')
+        ax.plot(plotdf['date'], plotdf['test_predicted_close_gmdh_2'], label='Предсказанная цена закрытия на тесте GMDH_2')
+    if transformer:
+        ax.plot(plotdf['date'], plotdf['train_predicted_close_transformer'],
+                label='Предсказанная цена закрытия на тренировке Transformer')
+        ax.plot(plotdf['date'], plotdf['test_predicted_close_transformer'],
+                label='Предсказанная цена закрытия на тесте Transformer')
+    ax.legend()
+    ax.set_title("Сравнение исходных и смоделированных цен")
+    # st.pyplot(fig)
+    #ax.plot()
+
+    models_dict = {'LSTM': model, 'SARIMA': arima_model, 'GMDH_1': model_gmdh1, 'GMDH_2': model_gmdh2, 'Transformer': pipeline}
+
+    return plotdf, metrics_df, models_dict

src/experiment_runner_for_portfolio.py

@@ -0,0 +1,283 @@
+import requests
+from experiment_runner_for_best_models import experiment
+from datetime import datetime
+from tqdm import tqdm
+import numpy as np
+import scipy.optimize as sco
+
+
+class DataLoader():
+    def __init__(self, correlation_threshold: float = 0.9):
+        self.correlation_threshold = correlation_threshold
+    # Function to get top N cryptocurrency tickers
+    def get_top_crypto_tickers(self, n):
+
+        url = 'https://api.coingecko.com/api/v3/coins/markets'
+        params = {
+            'vs_currency': 'usd',
+            'order': 'market_cap_desc',
+            'per_page': n,
+            'page': 1,
+            'sparkline': 'false'
+        }
+        response = requests.get(url, params=params)
+        data = response.json()
+        tickers = [coin['symbol'].upper() for coin in data]
+        return tickers
+
+
+    # Function to validate if a ticker is compatible with yfinance
+    def validate_ticker(self, ticker):
+        import yfinance as yf
+        try:
+            ticker += '-USD'
+            info = yf.Ticker(ticker).info
+            return bool(info)  # Returns True if info is not empty
+        except Exception:
+            return False
+
+    def experiment_data(self, top_n: int = 3, num_scale_steps: int = 1, scaling_strategy: str = 'average', time_step_backward: int = 15):
+        # Retrieve top N tickers
+        #top_n = 10
+        self.tickers = self.get_top_crypto_tickers(top_n)
+        # Validate tickers for compatibility with yfinance
+        self.valid_tickers = [ticker for ticker in self.tickers if self.validate_ticker(ticker)]
+        print("Compatible tickers for yfinance:", len(self.valid_tickers))
+        self.invalid_tickers = []
+
+        # Run experiments for each valid ticker
+        self.tickers_dict = {}
+        for ticker in self.valid_tickers:
+            try:
+                self.tickers_dict[ticker] = {}
+                plot_df, metrics_df, models_dict = experiment(ticker=ticker, num_scale_steps=num_scale_steps,
+                                                              scaling_strategy=scaling_strategy, time_step_backward=time_step_backward)
+                self.tickers_dict[ticker]['plot_df'] = plot_df
+                self.tickers_dict[ticker]['metrics_df'] = metrics_df
+                self.tickers_dict[ticker]['models_dict'] = models_dict
+            except AssertionError as e:  # Или другой конкретный тип ошибки
+                print('EXCEPTION ', str(e), ticker)
+                self.invalid_tickers.append(ticker)
+                continue
+
+        for invalid_ticker in self.invalid_tickers:
+            self.valid_tickers.remove(invalid_ticker)
+
+        # Mapping for prediction columns
+        test_predictions_model_mapper = {
+            'SARIMA': 'test_predicted_close_arima',
+            'LSTM': 'test_predicted_close',
+            'GMDH_1': 'test_predicted_close_gmdh_1',
+            'GMDH_2': 'test_predicted_close_gmdh_2',
+            'Transformer': 'test_predicted_close_transformer'
+        }
+        train_predictions_model_mapper = {
+            'SARIMA': 'train_predicted_close_arima',
+            'LSTM': 'train_predicted_close',
+            'GMDH_1': 'train_predicted_close_gmdh_1',
+            'GMDH_2': 'train_predicted_close_gmdh_2',
+            'Transformer': 'train_predicted_close_transformer'
+        }
+
+        # Determine global training and testing periods
+        self.global_min_date = datetime(2000, 1, 1, 0, 0)
+        self.global_max_date = datetime.now()
+        for ticker in self.valid_tickers:
+            train_last_valid_index = self.tickers_dict[ticker]['plot_df']['train_predicted_close_arima'].last_valid_index()
+            train_last_date = self.tickers_dict[ticker]['plot_df'].loc[train_last_valid_index, 'date']
+            if train_last_date < self.global_max_date:
+                self.global_max_date = train_last_date
+
+            test_first_valid_index = self.tickers_dict[ticker]['plot_df']['test_predicted_close_arima'].first_valid_index()
+            test_first_date = self.tickers_dict[ticker]['plot_df'].loc[test_first_valid_index, 'date']
+            if test_first_date > self.global_min_date:
+                self.global_min_date = test_first_date
+
+            print(train_last_date, train_last_valid_index, test_first_date, test_first_valid_index)
+
+        print(self.global_min_date , self.global_max_date)
+
+        # Collect predictions for the global periods
+        self.train_predictions_df_list = []
+        self.test_predictions_df_list = []
+        self.actual_prices_train = []
+        self.actual_prices_test = []
+        for ticker in tqdm(self.valid_tickers):
+            best_model = self.tickers_dict[ticker]['metrics_df'].T.sort_values(by='Test data MAPE', ascending=True).index[0]
+            train_predictions = self.tickers_dict[ticker]['plot_df'][['date', train_predictions_model_mapper[best_model]]]
+            train_predictions = train_predictions[train_predictions['date'] <= self.global_max_date]
+            train_predictions.rename(columns={train_predictions_model_mapper[best_model]: ticker}, inplace=True)
+            self.train_predictions_df_list.append(train_predictions)
+
+            actual_train = self.tickers_dict[ticker]['plot_df'][['date', 'original_close']]
+            actual_train = actual_train[actual_train['date'] <= self.global_max_date]
+            actual_train.rename(columns={'original_close': ticker}, inplace=True)
+            self.actual_prices_train.append(actual_train)
+
+            test_predictions = self.tickers_dict[ticker]['plot_df'][['date', test_predictions_model_mapper[best_model]]]
+            test_predictions = test_predictions[test_predictions['date'] >= self.global_min_date]
+            test_predictions.rename(columns={test_predictions_model_mapper[best_model]: ticker}, inplace=True)
+            self.test_predictions_df_list.append(test_predictions)
+
+            actual_test = self.tickers_dict[ticker]['plot_df'][['date', 'original_close']]
+            actual_test = actual_test[actual_test['date'] >= self.global_min_date]
+            actual_test.rename(columns={'original_close': ticker}, inplace=True)
+            self.actual_prices_test.append(actual_test)
+
+        self.selected_features = [self.valid_tickers[0]]
+        #correlation_threshold = 0.9
+        for idx, feature in enumerate(self.valid_tickers):
+            if idx == 0:
+                continue
+            print(idx, feature)
+            tmp = self.train_predictions_df_list[0].merge(self.train_predictions_df_list[idx], on='date', how='inner')
+            # Вычисляем корреляцию нового признака с уже выбранными
+            correlations = [abs(tmp[feature].corr(tmp[sel_feature])) for sel_feature in self.selected_features]
+            print(correlations)
+            max_correlation = max(correlations)
+
+            # Добавляем признак, если максимальная корреляция не превышает порог
+            if max_correlation < self.correlation_threshold:
+                self.selected_features.append(feature)
+                self.train_predictions_df_list[0] = self.train_predictions_df_list[0].merge(self.train_predictions_df_list[idx], on='date', how='inner')
+                self.actual_prices_train[0] = self.actual_prices_train[0].merge(self.actual_prices_train[idx], on='date', how='inner')
+                self.test_predictions_df_list[0] = self.test_predictions_df_list[0].merge(self.test_predictions_df_list[idx], on='date', how='inner')
+                self.actual_prices_test[0] = self.actual_prices_test[0].merge(self.actual_prices_test[idx], on='date', how='inner')
+        print(self.selected_features)
+
+        selected_features_and_date = ['date'] + self.selected_features
+        print(selected_features_and_date)
+
+        # Calculate covariance matrix for the training period
+        train_data = self.train_predictions_df_list[0].drop(columns=['date']).astype(float)
+        self.cov_matrix = train_data[self.selected_features].cov()
+        print("Covariance matrix for the training period:")
+        print(self.cov_matrix)
+
+        # Split the global test period into validation and test sets
+        self.validation_size = int(len(self.test_predictions_df_list[0][selected_features_and_date]) * 0.5)
+        self.validation_data = self.test_predictions_df_list[0][selected_features_and_date].iloc[:self.validation_size]
+        self.validation_actual = self.actual_prices_test[0][selected_features_and_date].iloc[:self.validation_size]
+        self.test_data = self.test_predictions_df_list[0][selected_features_and_date].iloc[self.validation_size:]
+        self.test_actual = self.actual_prices_test[0][selected_features_and_date].iloc[self.validation_size:]
+
+        # Проверка положительной определённости
+        if np.any(np.linalg.eigvals(self.cov_matrix) <= 0):
+            raise ValueError("Ковариационная матрица не является положительно определённой.")
+
+        return self.cov_matrix, self.validation_data, self.validation_actual, self.test_data, self.test_actual, self.train_predictions_df_list, self.actual_prices_train, self.test_predictions_df_list, self.actual_prices_test, self.tickers_dict
+
+
+class Portfolio():
+
+    def calculate_portfolio_metrics(self, weights, returns, cov_matrix):
+        portfolio_return = np.dot(weights, returns)
+        portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
+        return portfolio_return, portfolio_volatility
+
+    def optimize(self, returns, cov_matrix, target_return=None, allow_short=False):
+        num_assets = len(returns)
+        constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1})
+        if allow_short:
+            bounds = tuple((-1, 1) for _ in range(num_assets))  # Allow short positions
+        else:
+            bounds = tuple((0, 1) for _ in range(num_assets))  # Long-only portfolio
+        initial_weights = num_assets * [1. / num_assets]
+
+        if target_return is not None:
+            constraints = ({'type': 'eq', 'fun': lambda x: np.sum(x) - 1},
+                           {'type': 'eq', 'fun': lambda x: np.dot(x, returns) - target_return})
+
+        result = sco.minimize(
+            lambda w: self.calculate_portfolio_metrics(w, returns, cov_matrix)[1],
+            initial_weights,
+            method='SLSQP',
+            bounds=bounds,
+            constraints=constraints
+        )
+        return result.x
+
+    def process_period(self, data, actual_data, cov_matrix, target_return=None, allow_short=False):
+        # Forecast and optimize portfolio for each point T -> T+1 in validation and test data
+        realized_returns = []
+        predicted_returns = []
+        realized_volatilities = []
+        predicted_volatilities = []
+        for i in range(len(data) - 1):
+            current_data = data.iloc[i:i + 2]  # Include current day and prediction for next day
+            actual_current_data = actual_data.iloc[i:i + 2]  # Actual prices for T and T+1
+            # Calculate predicted return using actual price at T and predicted price at T+1
+            predicted_return = (current_data.drop(columns=['date']).iloc[1]-
+                                actual_current_data.drop(columns=['date']).iloc[0]) / actual_current_data.drop(columns=['date']).iloc[0]
+            # Optimize portfolio based on predicted returns
+            self.weights = self.optimize(predicted_return, cov_matrix, target_return=target_return,
+                                         allow_short=allow_short)
+            pred_return, pred_volatility = self.calculate_portfolio_metrics(weights=self.weights, returns=predicted_return,
+                                                                       cov_matrix=cov_matrix)
+            # Compute realized return using actual prices for T and T+1
+            realized_return = (actual_current_data.drop(columns=['date']).iloc[1] -
+                               actual_current_data.drop(columns=['date']).iloc[0]) / actual_current_data.drop(columns=['date']).iloc[0]
+
+            real_return, real_volatility = self.calculate_portfolio_metrics(weights=self.weights, returns=realized_return,
+                                                                               cov_matrix=cov_matrix)
+            realized_returns.append(real_return)
+            predicted_returns.append(pred_return)
+            realized_volatilities.append(real_volatility)
+            predicted_volatilities.append(pred_volatility)
+        return predicted_returns, realized_returns, predicted_volatilities, realized_volatilities
+
+
+    # Calculate accuracy metrics for validation and test sets
+    def calculate_accuracy(self, predicted, realized):
+        return np.mean(np.abs(np.array(predicted) - np.array(realized))) / np.mean(realized)
+
+
+    # Calculate Sharpe ratio deviation
+    def calculate_sharpe_ratio_deviation(self, predicted_returns, realized_returns, predicted_vol, realized_vol):
+        predicted_sharpe = np.mean(predicted_returns) / np.mean(predicted_vol)
+        realized_sharpe = np.mean(realized_returns) / np.mean(realized_vol)
+        return abs(predicted_sharpe - realized_sharpe)
+
+    def optimize_portfolio(self, cov_matrix, validation_data, validation_actual, test_data, test_actual, target_return: int | None = None, allow_short: bool = False):
+
+        # Calculate validation metrics
+        self.val_pred_returns, self.val_realized_returns, self.val_pred_vol, self.val_realized_vol = self.process_period(data=validation_data,
+                                                                                                actual_data=validation_actual,
+                                                                                                cov_matrix=cov_matrix,
+                                                                                                target_return=target_return,
+                                                                                                allow_short=allow_short)
+        self.test_pred_returns, self.test_realized_returns, self.test_pred_vol, self.test_realized_vol = self.process_period(data=test_data,
+                                                                                                    actual_data=test_actual,
+                                                                                                    cov_matrix=cov_matrix,
+                                                                                                    target_return=target_return,
+                                                                                                    allow_short=allow_short)
+
+        #print(self.val_pred_returns, self.val_realized_returns, self.val_pred_vol, self.val_realized_vol)
+        #print(self.test_pred_returns, self.test_realized_returns, self.test_pred_vol, self.test_realized_vol)
+
+
+        self.val_return_accuracy = self.calculate_accuracy(self.val_pred_returns, self.val_realized_returns)
+        self.val_volatility_accuracy = self.calculate_accuracy(self.val_pred_vol, self.val_realized_vol)
+        self.val_sharpe_deviation = self.calculate_sharpe_ratio_deviation(self.val_pred_returns, self.val_realized_returns, self.val_pred_vol, self.val_realized_vol)
+        self.val_sum_pred_returns = np.sum(self.val_pred_returns)
+        self.val_sum_realized_returns = np.sum(self.val_realized_returns)
+
+        self.test_return_accuracy = self.calculate_accuracy(self.test_pred_returns, self.test_realized_returns)
+        self.test_volatility_accuracy = self.calculate_accuracy(self.test_pred_vol, self.test_realized_vol)
+        self.test_sharpe_deviation = self.calculate_sharpe_ratio_deviation(self.test_pred_returns, self.test_realized_returns, self.test_pred_vol, self.test_realized_vol)
+        self.test_sum_pred_returns = np.sum(self.test_pred_returns)
+        self.test_sum_realized_returns = np.sum(self.test_realized_returns)
+
+        print(f"Validation Return Accuracy: {self.val_return_accuracy}")
+        print(f"Validation Volatility Accuracy: {self.val_volatility_accuracy}")
+        print(f"Validation Sharpe Ratio Deviation: {self.val_sharpe_deviation}")
+        print(f"Validation Pred Return Sum: {self.val_sum_pred_returns}")
+        print(f"Validation Actual Return Sum: {self.val_sum_realized_returns}")
+
+        print(f"Test Return Accuracy: {self.test_return_accuracy}")
+        print(f"Test Volatility Accuracy: {self.test_volatility_accuracy}")
+        print(f"Test Sharpe Ratio Deviation: {self.test_sharpe_deviation}")
+        print(f"Test Pred Return Sum: {self.test_sum_pred_returns}")
+        print(f"Test Actual Return Sum: {self.test_sum_realized_returns}")
+
+        #return val_return_accuracy, val_volatility_accuracy, val_sharpe_deviation, np.sum(val_pred_vol), np.sum(val_realized_returns), test_return_accuracy, test_volatility_accuracy, test_sharpe_deviation, np.sum(test_pred_vol), np.sum(test_realized_returns)

src/pages/1_Model_optimization.py

@@ -0,0 +1,688 @@
+import pandas as pd
+import numpy as np
+import math
+
+# For Evalution we will use these library
+
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from sklearn.preprocessing import MinMaxScaler
+
+# For model building we will use these library
+
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Dense
+from tensorflow.keras.layers import LSTM
+from tensorflow.keras import initializers
+from tensorflow.keras.callbacks import EarlyStopping
+
+# For PLotting we will use these library
+import matplotlib.pyplot as plt
+
+import yfinance as yf
+
+import streamlit as st
+
+from gmdh import CriterionType, Criterion, Multi, Combi, Mia, Ria, PolynomialType
+from chronos import ChronosPipeline
+import torch
+import pmdarima as pm
+from pages.utils.utils import create_dataset, make_prediction, make_prediction_recursive
+
+from io import StringIO
+
+st.set_page_config(
+    page_title="Model optimization",
+    page_icon="📈")
+
+@st.cache_data
+def get_pipeline():
+    pipeline = ChronosPipeline.from_pretrained(
+        "amazon/chronos-t5-tiny",
+        device_map="cpu",  # use "cpu" for CPU inference and "mps" for Apple Silicon
+        torch_dtype=torch.bfloat16)
+    return pipeline
+
+pipeline = get_pipeline()
+seed = 42
+st.title("Daily price prediction")
+tickers = ['BTC', 'ETH', 'BNB', #'USDC',
+            'XRP', 'STETH','ADA','DOGE',#'FGC',
+           'WTRX','LTC','SOL','TRX','DOT','MATIC','BCH','WBTC','TON11419',
+           'DAI','SHIB','AVAX','BUSD','LEO','LINK']
+intervals = ['1d']#, '5d', '1wk', '1mo', '3mo'] #['1m', '2m', '5m','15m','30m','60m','90m','1h','1d','5d','1wk','1mo','3mo']
+ticker = st.selectbox("Ticker", options=tickers)
+interval = st.selectbox("Interval of raw data", options = intervals)
+
+int_to_periods = {'1m':'5d', '2m':'1mo', '5m': '1mo','15m': '1mo','30m': '1mo','60m': '1mo','90m': '1mo',
+           '1h': '1y','1d': '10y','5d': '10y','1wk': '10y','1mo': '10y','3mo': '10y'}
+
+period_cut = {'1d': '2022-02-19', '5d': '2020-06-19', '1wk': '2020-06-19', '1mo': '2014-06-19', '3mo': '2014-06-19'}
+
+uploaded_file = st.file_uploader("Choose a file")
+
+
+try:
+    maindf = yf.download(tickers = f"{ticker}-USD",  # list of tickers
+                period = int_to_periods[interval],         # time period
+                interval = interval,       # trading interval
+                prepost = False,       # download pre/post market hours data?
+                repair = True,)         # repair obvious price errors e.g. 100x?
+    if len(maindf) == 0:
+        raise FileNotFoundError
+except:
+    maindf = pd.read_csv(f'{ticker}.csv')
+
+if uploaded_file is not None:
+    # To read file as bytes:
+    bytes_data = uploaded_file.getvalue()
+    # To convert to a string based IO:
+    stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
+    # To read file as string:
+    string_data = stringio.read()
+
+    # Can be used wherever a "file-like" object is accepted:
+    maindf = pd.read_csv(uploaded_file)
+    st.write(maindf.head())
+
+
+
+maindf=maindf.reset_index()
+maindf['Date'] = pd.to_datetime(maindf['Date'], format='%Y-%m-%d')
+
+#maindf = pd.read_csv('BTC-USD.csv')
+print('Total number of days present in the dataset: ',maindf.shape[0])
+print('Total number of fields present in the dataset: ',maindf.shape[1])
+print(maindf.head())
+
+y_overall = maindf.copy()#.loc[(maindf['Date'] >= '2014-09-17')]
+                     #& (maindf['Date'] <= '2022-02-19')]
+
+global_expander = st.sidebar.expander('Параметры режима моделирования')
+scaling_expander= st.sidebar.expander('Режим масштабирования')
+scaling_strategy_list = ['median', 'average', 'undersampling']
+scale_step_type_list = ['D','W','M','Y']
+scale_step_type = scaling_expander.selectbox('Шаг масштабирования', scale_step_type_list)
+num_scale_steps = scaling_expander.slider('Размер шага масштабирования', 1, 100, 1)
+
+y_overall = y_overall[['Date','Close']]
+if num_scale_steps > 1:
+    scaling_strategy = scaling_expander.selectbox('Метод масштабирования', scaling_strategy_list)
+    scaling_step_combined = str(num_scale_steps) + scale_step_type
+    # Определяем сегодняшнюю дату
+    today = pd.Timestamp.now().normalize()
+    if scaling_strategy == 'average':
+        # y_overall = y_overall.groupby(pd.Grouper(key = 'Date', freq = scaling_step_combined)).mean()
+        # Добавляем колонку для конца интервала
+        y_overall['Interval_End'] = today - (
+                (today - y_overall['Date']) // pd.Timedelta(scaling_step_combined)) * pd.Timedelta(
+            scaling_step_combined)
+        # Группируем по интервалам и считаем среднее
+        y_overall = y_overall.groupby('Interval_End')['Close'].mean().reset_index()
+        # Сортируем результат
+        y_overall = y_overall.sort_values('Interval_End')  # .reset_index(drop=True)
+        y_overall = y_overall.rename({'Interval_End': 'Date'}, axis=1)
+    elif scaling_strategy == 'median':
+        # y_overall = y_overall.groupby(pd.Grouper(key = 'Date', freq = scaling_step_combined)).median()
+        # y_overall = y_overall.groupby(pd.Grouper(key = 'Date', freq = scaling_step_combined)).mean()
+        # Добавляем колонку для конца интервала
+        y_overall['Interval_End'] = today - (
+                (today - y_overall['Date']) // pd.Timedelta(scaling_step_combined)) * pd.Timedelta(
+            scaling_step_combined)
+        # Группируем по интервалам и считаем среднее
+        y_overall = y_overall.groupby('Interval_End')['Close'].median().reset_index()
+        # Сортируем результат
+        y_overall = y_overall.sort_values('Interval_End')  # .reset_index(drop=True)
+        y_overall = y_overall.rename({'Interval_End': 'Date'}, axis=1)
+    else:
+        # y_overall = y_overall.resample(on = 'Date', rule = scaling_step_combined).last()
+        # Устанавливаем 'Date' как индекс, если это ещё не сделано
+        # y_overall = y_overall.set_index('Date')
+        # y_overall.columns = y_overall.columns.droplevel(1)
+        y_overall = y_overall.resample(on='Date', rule=scaling_step_combined, origin='end').last()
+        y_overall = y_overall.reset_index()
+
+
+#names = cycle(['Stock Open Price','Stock Close Price','Stock High Price','Stock Low Price'])
+fig, ax = plt.subplots()
+#ax.plot(y_overall.Date, y_overall['Close'], label = 'Stock Close Price')
+ax.plot(y_overall['Close'], label = 'Stock Close Price')
+
+ax.legend()
+ax.set_title(f'Динамика цены закрытия для {ticker}')
+
+#st.image(fig)
+st.pyplot(fig)
+#fig.show()
+
+
+
+
+train = st.sidebar.button('Train')
+time_step_backward = st.sidebar.slider('Количество шагов назад для предикторов', 5, 60, 15)
+time_step_forward = st.sidebar.slider('Количество шагов вперед для таргета', 1, 60, 1)
+
+
+pred_days = 1
+recursive_pred = False
+if time_step_forward == 1:
+    expander = st.sidebar.expander('Режим ресурсивного прогноза')
+    pred_days = expander.slider('Количество шагов для ресурсивного прогноза', 1, 30, 15)
+    recursive_pred = expander.checkbox('Запустить рекурсивный прогноз')
+
+
+
+GMDH = st.sidebar.checkbox('Добавить режим МГУА')
+transformer = st.sidebar.checkbox('Добавить режим Transformer')
+if GMDH:
+    expander1 = st.sidebar.expander('Гиперпараметры МГУА')
+    GMDHs = {'Combi': Combi(), 'Multi': Multi(), 'Mia': Mia(), 'Ria': Ria()}
+    criterions = {'Критерий регулярности (несимметричная форма)': CriterionType.REGULARITY,
+                  'Критерий регулярности (симметричная форма)': CriterionType.SYM_REGULARITY,
+                  'Критерий стабильности (несимметричная форма)': CriterionType.STABILITY,
+                  'Критерий стабильности (симметричная форма)': CriterionType.SYM_STABILITY,
+                  'Критерий минимума смещения коэффициентов': CriterionType.UNBIASED_COEFFS,
+                  'Критерий минимума смещения решений (несимметричная форма)': CriterionType.UNBIASED_OUTPUTS,
+                  'Критерий минимума смещения решений (симметричная форма)': CriterionType.SYM_UNBIASED_OUTPUTS,
+                  'Абсолютно помехоустойчивый критерий (несимметричная форма)': CriterionType.ABSOLUTE_NOISE_IMMUNITY,
+                  'Абсолютно помехоустойчивый критерий (симметричная форма)': CriterionType.SYM_ABSOLUTE_NOISE_IMMUNITY}
+    polynoms = {'LINEAR': PolynomialType.LINEAR,
+                  'LINEAR_COV': PolynomialType.LINEAR_COV,
+                  'QUADRATIC': PolynomialType.QUADRATIC}
+    GMDH_algo = expander1.selectbox("Алгоритм МГУА", options = GMDHs.keys())
+    criterion = expander1.selectbox("Внешний критерий", options = criterions.keys())
+    p_average = expander1.slider('p_average', 1, 10, 1)
+    limit = expander1.number_input('limit', value = 0.)
+    k_best = expander1.slider('k_best', 1, 10, 3 if GMDH_algo == 'Mia' else 1)
+    polynom = expander1.selectbox("Вид базовых полиномов", options = polynoms.keys())
+
+
+y_overall.columns = y_overall.columns.droplevel(1)#.droplevel()
+#y_overall = y_overall.reset_index()
+
+
+if train:
+    my_bar = st.progress(0, text='Model training progress. Truncating the dataset now')
+    # Lets First Take all the Close Price
+    closedf = y_overall[['Date', 'Close']]#maindf[['Date', 'Close']]
+    print("Shape of close dataframe:", closedf.shape)
+    closedf = closedf[-1000:]#closedf[closedf['Date'] > period_cut[interval]]
+    close_stock = closedf.copy()
+    print("Total data for prediction: ", closedf.shape[0])
+    my_bar.progress(10 + 1, text='Truncated the dataset -> Scaling it')
+    # deleting date column and normalizing using MinMax Scaler
+
+
+    del closedf['Date']
+    scaler = MinMaxScaler(feature_range=(0, 1))
+    #closedf = scaler.fit_transform(np.array(closedf).reshape(-1, 1))
+    print(closedf.shape)
+
+    my_bar.progress(20 + 1, text='Scaled the dataset -> Splitting it into subsamples')
+    # we keep the training set as 60% and 40% testing set
+
+    training_size = int(len(closedf) * 0.70)
+    test_size = len(closedf) - training_size
+    assert test_size > time_step_backward + time_step_forward, "Test_size is shorter than time_step_backward + time_step_forward"
+    train_data, test_data = closedf[0:training_size], closedf[training_size:len(closedf)]
+    train_data = scaler.fit_transform(train_data)
+    test_data = scaler.transform(test_data)
+    print("train_data: ", train_data.shape)
+    print("test_data: ", test_data.shape)
+
+    my_bar.progress(30 + 1, text='Split it into subsamples -> Cutting them into observations')
+
+    X_train, y_train = create_dataset(train_data, time_step_backward, time_step_forward)
+    X_test, y_test = create_dataset(test_data, time_step_backward, time_step_forward)
+
+    print("X_train: ", X_train.shape)
+    print("y_train: ", y_train.shape)
+    print("X_test: ", X_test.shape)
+    print("y_test", y_test.shape)
+
+    # reshape input to be [samples, time steps, features] which is required for LSTM
+    X_train_gmdh = X_train.copy()
+    X_test_gmdh = X_test.copy()
+    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
+    X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)
+
+    print("X_train: ", X_train.shape)
+    print("X_test: ", X_test.shape)
+
+    my_bar.progress(40 + 1, text='Cut it into observations -> Training the model')
+    model = Sequential()
+    model.add(LSTM(10, input_shape=(None, 1), activation="relu",
+                   kernel_initializer = initializers.GlorotNormal(seed = seed), bias_initializer = initializers.GlorotNormal(seed = seed)))
+    model.add(Dense(1,
+                   kernel_initializer = initializers.GlorotNormal(seed = seed), bias_initializer = initializers.GlorotNormal(seed = seed)))
+    model.compile(loss="mean_squared_error", optimizer="adam")
+    callback = EarlyStopping(monitor='loss', patience=30, restore_best_weights = True)
+    history = model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=100, batch_size=32, verbose=10,
+                        callbacks = [callback])
+
+    arima_model = pm.auto_arima(train_data,
+                          m=12,  # frequency of series
+                          seasonal=True,  # TRUE if seasonal series
+                          d=None,  # let model determine 'd'
+                          test='adf',  # use adftest to find optimal 'd'
+                          start_p=0, start_q=0,  # minimum p and q
+                          max_p=time_step_backward, max_q=time_step_backward,  # maximum p and q
+                          D=None,  # let model determine 'D'
+                          trace=True,
+                          error_action='ignore',
+                          suppress_warnings=True,
+                          stepwise=True)
+    st.text(arima_model.summary())
+
+    if GMDH:
+        model_gmdh = GMDHs[GMDH_algo]
+        if GMDH_algo == 'Combi':
+            model_gmdh.fit(X_train_gmdh, y_train, p_average = p_average, limit = limit, test_size=0.3,
+                           criterion = Criterion(criterion_type = criterions[criterion]))
+        if GMDH_algo == 'Multi':
+            model_gmdh.fit(X_train_gmdh, y_train, p_average=p_average, limit=limit, test_size=0.3,
+                           criterion=Criterion(criterion_type=criterions[criterion]),
+                            k_best = k_best)
+        if GMDH_algo in ['Ria', 'Mia']:
+            model_gmdh.fit(X_train_gmdh, y_train, p_average=p_average, limit=limit, test_size=0.3,
+                           criterion=Criterion(criterion_type=criterions[criterion]),
+                            k_best = k_best, polynomial_type = polynoms[polynom])
+        st.write(f"GMDH model: {model_gmdh.get_best_polynomial()}")
+
+
+    my_bar.progress(70 + 1, text='Trained model -> Calculating loss')
+    import matplotlib.pyplot as plt
+
+    loss = history.history['loss']
+    val_loss = history.history['val_loss']
+
+    epochs = range(len(loss))
+
+    fig, ax = plt.subplots()
+    ax.plot(epochs, loss, 'r', label='Training loss')
+    ax.plot(epochs, val_loss, 'b', label='Validation loss')
+    ax.legend()
+    ax.set_title('Потери на обучении и валидации')
+    #ax.set_ylim[0, 0.2]
+    st.pyplot(fig)
+
+    my_bar.progress(80 + 1, text='Calculated loss -> Scoring the dataset')
+
+
+    original_ytrain = scaler.inverse_transform(y_train.reshape(-1, 1))
+    original_ytest = scaler.inverse_transform(y_test.reshape(-1, 1))
+
+    train_predict, test_predict = make_prediction(X_train, X_test, method='LSTM', model=model,
+                    scaler=scaler, time_step_forward=time_step_forward)
+    train_predict_arima, test_predict_arima = make_prediction(X_train, X_test, method='SARIMA', model=arima_model,
+                    scaler=scaler, time_step_forward=time_step_forward)
+    if GMDH:
+        train_predict_gmdh, test_predict_gmdh = make_prediction(X_train_gmdh, X_test_gmdh, method='GMDH', model=model_gmdh,
+                        scaler=scaler, time_step_forward=time_step_forward)
+    if transformer:
+        X_train_forecast_median, X_test_forecast_median = make_prediction(X_train_gmdh, X_test_gmdh, method='Transformer', model=pipeline,
+                        scaler=scaler, time_step_forward=time_step_forward)
+
+    my_bar.progress(85 + 1, text='Scored the dataset -> Calculating perfomance metrics')
+
+    # Evaluation metrices RMSE and MAE
+    metrics_tmp = {}
+    metrics1 = {}
+    metrics1['LSTM'] = []
+    #metrics1['Transformer'] = []
+    metrics_tmp["Train data RMSE"] = math.sqrt(mean_squared_error(original_ytrain, train_predict))
+    metrics_tmp["Train data MSE"] = mean_squared_error(original_ytrain, train_predict)
+    metrics_tmp["Train data MAE"] =  mean_absolute_error(original_ytrain, train_predict)
+    print("-------------------------------------------------------------------------------------")
+    metrics_tmp["Test data RMSE"] =  math.sqrt(mean_squared_error(original_ytest, test_predict))
+    metrics_tmp["Test data MSE"] =  mean_squared_error(original_ytest, test_predict)
+    metrics_tmp["Test data MAE"] =  mean_absolute_error(original_ytest, test_predict)
+    #metrics_tmp["Train data explained variance regression score"] = explained_variance_score(original_ytrain, train_predict)
+    #metrics_tmp["Test data explained variance regression score"] = explained_variance_score(original_ytest, test_predict)
+    metrics_tmp["Train data R2 score"] =  r2_score(original_ytrain, train_predict)
+    metrics_tmp["Test data R2 score"] =  r2_score(original_ytest, test_predict)
+    for metric in metrics_tmp:
+        print(metric, ': ', metrics_tmp[metric])
+        metrics1['LSTM'].append(metrics_tmp[metric])
+
+
+    metrics1['SARIMA'] = []
+    # metrics1['Transformer'] = []
+    metrics_tmp["Train data RMSE"] = math.sqrt(mean_squared_error(original_ytrain, train_predict_arima))
+    metrics_tmp["Train data MSE"] = mean_squared_error(original_ytrain, train_predict_arima)
+    metrics_tmp["Train data MAE"] = mean_absolute_error(original_ytrain, train_predict_arima)
+    print("-------------------------------------------------------------------------------------")
+    metrics_tmp["Test data RMSE"] = math.sqrt(mean_squared_error(original_ytest, test_predict_arima))
+    metrics_tmp["Test data MSE"] = mean_squared_error(original_ytest, test_predict_arima)
+    metrics_tmp["Test data MAE"] = mean_absolute_error(original_ytest, test_predict_arima)
+    # metrics_tmp["Train data explained variance regression score"] = explained_variance_score(original_ytrain, train_predict)
+    # metrics_tmp["Test data explained variance regression score"] = explained_variance_score(original_ytest, test_predict)
+    metrics_tmp["Train data R2 score"] = r2_score(original_ytrain, train_predict_arima)
+    metrics_tmp["Test data R2 score"] = r2_score(original_ytest, test_predict_arima)
+    for metric in metrics_tmp:
+        print(metric, ': ', metrics_tmp[metric])
+        metrics1['SARIMA'].append(metrics_tmp[metric])
+    if GMDH:
+        metrics1['GMDH'] = []
+        metrics_tmp["Train data RMSE"] = math.sqrt(mean_squared_error(original_ytrain, train_predict_gmdh))
+        metrics_tmp["Train data MSE"] = mean_squared_error(original_ytrain, train_predict_gmdh)
+        metrics_tmp["Train data MAE"] =  mean_absolute_error(original_ytrain, train_predict_gmdh)
+        print("-------------------------------------------------------------------------------------")
+        metrics_tmp["Test data RMSE"] =  math.sqrt(mean_squared_error(original_ytest, test_predict_gmdh))
+        metrics_tmp["Test data MSE"] =  mean_squared_error(original_ytest, test_predict_gmdh)
+        metrics_tmp["Test data MAE"] =  mean_absolute_error(original_ytest, test_predict_gmdh)
+        #metrics_tmp["Train data explained variance regression score"] = explained_variance_score(original_ytrain, train_predict)
+        #metrics_tmp["Test data explained variance regression score"] = explained_variance_score(original_ytest, test_predict)
+        metrics_tmp["Train data R2 score"] =  r2_score(original_ytrain, train_predict_gmdh)
+        metrics_tmp["Test data R2 score"] =  r2_score(original_ytest, test_predict_gmdh)
+        for metric in metrics_tmp:
+            print(metric, ': ', metrics_tmp[metric])
+            metrics1['GMDH'].append(metrics_tmp[metric])
+
+    if transformer:
+        metrics1['Transformer'] = []
+        metrics_tmp["Train data RMSE"] = math.sqrt(mean_squared_error(original_ytrain, X_train_forecast_median))
+        metrics_tmp["Train data MSE"] = mean_squared_error(original_ytrain, X_train_forecast_median)
+        metrics_tmp["Train data MAE"] = mean_absolute_error(original_ytrain, X_train_forecast_median)
+        print("-------------------------------------------------------------------------------------")
+        metrics_tmp["Test data RMSE"] = math.sqrt(mean_squared_error(original_ytest, X_test_forecast_median))
+        metrics_tmp["Test data MSE"] = mean_squared_error(original_ytest, X_test_forecast_median)
+        metrics_tmp["Test data MAE"] = mean_absolute_error(original_ytest, X_test_forecast_median)
+        # metrics_tmp["Train data explained variance regression score"] = explained_variance_score(original_ytrain, train_predict)
+        # metrics_tmp["Test data explained variance regression score"] = explained_variance_score(original_ytest, test_predict)
+        metrics_tmp["Train data R2 score"] = r2_score(original_ytrain, X_train_forecast_median)
+        metrics_tmp["Test data R2 score"] = r2_score(original_ytest, X_test_forecast_median)
+        for metric in metrics_tmp:
+            print(metric, ': ', metrics_tmp[metric])
+            metrics1['Transformer'].append(metrics_tmp[metric])
+
+    metrics_df = pd.DataFrame.from_dict(metrics1, orient = 'columns')#(metrics, columns = ['LSTM', 'GMDH'])
+    metrics_df.index = metrics_tmp.keys()
+    st.write(metrics_df)
+    #print("Train data MGD: ", mean_gamma_deviance(original_ytrain, train_predict))
+    #print("Test data MGD: ", mean_gamma_deviance(original_ytest, test_predict))
+    #print("----------------------------------------------------------------------")
+    #print("Train data MPD: ", mean_poisson_deviance(original_ytrain, train_predict))
+    #print("Test data MPD: ", mean_poisson_deviance(original_ytest, test_predict))
+
+
+    my_bar.progress(90 + 1, text='Calculated performance metrics -> Plotting predictions')
+
+    # shift train predictions for plotting
+
+    lag = time_step_backward + (time_step_forward - 1)
+    trainPredictPlot_arima = np.empty_like(closedf)
+    trainPredictPlot_arima[:, :] = np.nan
+    trainPredictPlot_arima[lag:len(train_predict_arima) + lag, :] = train_predict_arima
+    print(trainPredictPlot_arima[lag:len(train_predict_arima) + lag, :].shape, train_predict_arima.shape)
+    print("Train predicted data: ", trainPredictPlot_arima.shape)
+
+    # shift test predictions for plotting
+    testPredictPlot_arima = np.empty_like(closedf)
+    testPredictPlot_arima[:, :] = np.nan
+    testPredictPlot_arima[len(train_predict_arima) + (lag * 2):len(closedf), :] = test_predict_arima
+    print(testPredictPlot_arima[len(train_predict_arima) + (lag * 2):len(closedf), :].shape, test_predict_arima.shape)
+    print("Test predicted data: ", testPredictPlot_arima.shape)
+
+
+
+    trainPredictPlot = np.empty_like(closedf)
+    trainPredictPlot[:, :] = np.nan
+    trainPredictPlot[lag:len(train_predict) + lag, :] = train_predict
+    print(trainPredictPlot[lag:len(train_predict) + lag, :].shape, train_predict.shape)
+    print("Train predicted data: ", trainPredictPlot.shape)
+
+    # shift test predictions for plotting
+    testPredictPlot = np.empty_like(closedf)
+    testPredictPlot[:, :] = np.nan
+    testPredictPlot[len(train_predict) + (lag * 2):len(closedf), :] = test_predict
+    print(testPredictPlot[len(train_predict) + (lag * 2):len(closedf), :].shape, test_predict.shape)
+    print("Test predicted data: ", testPredictPlot.shape)
+
+    if GMDH:
+        trainPredictPlot_gmdh = np.empty_like(closedf)
+        trainPredictPlot_gmdh[:, :] = np.nan
+        trainPredictPlot_gmdh[lag:len(train_predict_gmdh) + lag, :] = train_predict_gmdh
+        print(trainPredictPlot_gmdh[lag:len(train_predict_gmdh) + lag, :].shape, train_predict_gmdh.shape)
+
+        testPredictPlot_gmdh = np.empty_like(closedf)
+        testPredictPlot_gmdh[:, :] = np.nan
+        testPredictPlot_gmdh[len(train_predict_gmdh) + (lag * 2):len(closedf), :] = test_predict_gmdh
+        print(testPredictPlot_gmdh[len(train_predict_gmdh) + (lag * 2):len(closedf), :].shape, test_predict_gmdh.shape)
+
+    if transformer:
+        trainPredictPlot_transformer = np.empty_like(closedf)
+        trainPredictPlot_transformer[:, :] = np.nan
+        trainPredictPlot_transformer[lag:len(X_train_forecast_median) + lag, :] = X_train_forecast_median
+        print(trainPredictPlot_transformer[lag:len(X_train_forecast_median) + lag, :].shape,
+              X_train_forecast_median.shape)
+
+        testPredictPlot_transformer = np.empty_like(closedf)
+        testPredictPlot_transformer[:, :] = np.nan
+        testPredictPlot_transformer[len(X_train_forecast_median) + (lag * 2):len(closedf), :] = X_test_forecast_median
+        print(testPredictPlot_transformer[len(X_train_forecast_median) + (lag * 2):len(closedf), :].shape,
+              X_test_forecast_median.shape)
+
+    if GMDH:
+        if transformer:
+            plotdf = pd.DataFrame({'date': close_stock['Date'],
+                                   'original_close': close_stock['Close'],
+                                   'train_predicted_close_arima': trainPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_arima': testPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close': trainPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close': testPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close_gmdh': trainPredictPlot_gmdh.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_gmdh': testPredictPlot_gmdh.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close_transformer': trainPredictPlot_transformer.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_transformer': testPredictPlot_transformer.reshape(1, -1)[0].tolist()})
+        elif not transformer:
+            plotdf = pd.DataFrame({'date': close_stock['Date'],
+                                   'original_close': close_stock['Close'],
+                                   'train_predicted_close_arima': trainPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_arima': testPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close': trainPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close': testPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close_gmdh': trainPredictPlot_gmdh.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_gmdh': testPredictPlot_gmdh.reshape(1, -1)[0].tolist()})
+    elif not GMDH:
+        if transformer:
+            plotdf = pd.DataFrame({'date': close_stock['Date'],
+                                   'original_close': close_stock['Close'],
+                                   'train_predicted_close_arima': trainPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_arima': testPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                                   'train_predicted_close': trainPredictPlot.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close': testPredictPlot.reshape(1, -1)[0].tolist(),
+                                  'train_predicted_close_transformer': trainPredictPlot_transformer.reshape(1, -1)[0].tolist(),
+                                   'test_predicted_close_transformer': testPredictPlot_transformer.reshape(1, -1)[0].tolist()})
+        else:
+            plotdf = pd.DataFrame({'date': close_stock['Date'],
+                               'original_close': close_stock['Close'],
+                               'train_predicted_close_arima': trainPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                               'test_predicted_close_arima': testPredictPlot_arima.reshape(1, -1)[0].tolist(),
+                               'train_predicted_close': trainPredictPlot.reshape(1, -1)[0].tolist(),
+                               'test_predicted_close': testPredictPlot.reshape(1, -1)[0].tolist()})
+    fig, ax = plt.subplots()
+    ax.plot(plotdf['date'], plotdf['original_close'], label='Оригинальная цена закрытия')
+    ax.plot(plotdf['date'], plotdf['train_predicted_close_arima'], label='Предсказанная цена закрытия на тренировке SARIMA')
+    ax.plot(plotdf['date'], plotdf['test_predicted_close_arima'], label='Предсказанная цена закрытия на тесте SARIMA')
+    ax.plot(plotdf['date'], plotdf['train_predicted_close'], label='Предсказанная цена закрытия на тренировке')
+    ax.plot(plotdf['date'], plotdf['test_predicted_close'], label='Предсказанная цена закрытия на тесте')
+    if GMDH:
+        ax.plot(plotdf['date'], plotdf['train_predicted_close_gmdh'], label='Предсказанная цена закрытия на тренировке GMDH')
+        ax.plot(plotdf['date'], plotdf['test_predicted_close_gmdh'], label='Предсказанная цена закрытия на тесте GMDH')
+    if transformer:
+        ax.plot(plotdf['date'], plotdf['train_predicted_close_transformer'], label='Предсказанная цена закрытия на тренировке Transformer')
+        ax.plot(plotdf['date'], plotdf['test_predicted_close_transformer'], label='Предсказанная цена закрытия на тесте Transformer')
+    ax.legend()
+    ax.set_title("Сравнение исходных и смоделированных цен")
+    st.pyplot(fig)
+
+
+    my_bar.progress(100, text='Done')
+
+
+    if recursive_pred:
+        lst_output_arima = make_prediction_recursive(test_data=test_data, method='SARIMA', model=arima_model,
+                                                     scaler=scaler, pred_days=pred_days,
+                                                     time_step_backward=time_step_backward)
+        lst_output_lstm = make_prediction_recursive(test_data=test_data, method='LSTM', model=model,
+                                                    scaler=scaler, pred_days=pred_days,
+                                                    time_step_backward=time_step_backward)
+        if GMDH:
+            lst_output_gmdh = make_prediction_recursive(test_data=test_data, method='GMDH', model=model_gmdh,
+                                                        scaler=scaler, pred_days=pred_days,
+                                                        time_step_backward=time_step_backward)
+        if transformer:
+            lst_output_transformer = make_prediction_recursive(test_data=test_data, method='Transformer', model=pipeline,
+                                                               scaler=scaler, pred_days=pred_days,
+                                                               time_step_backward=time_step_backward)
+
+        """
+        x_input = test_data[len(test_data) - time_step_backward:].reshape(1, -1)
+        temp_input = list(x_input)
+        temp_input = temp_input[0].tolist()
+
+
+        lst_output = []
+        n_steps = time_step_backward
+        i = 0
+        while (i < pred_days):
+
+            if (len(temp_input) > time_step_backward):
+
+                x_input = np.array(temp_input[1:])
+                # print("{} day input {}".format(i,x_input))
+                x_input = x_input.reshape(1, -1)
+                x_input = x_input.reshape((1, n_steps, 1))
+
+                yhat = model.predict(x_input, verbose=0)
+                # print("{} day output {}".format(i,yhat))
+                temp_input.extend(yhat[0].tolist())
+                temp_input = temp_input[1:]
+                # print(temp_input)
+
+                lst_output.extend(yhat.tolist())
+                i = i + 1
+
+            else:
+
+                x_input = x_input.reshape((1, n_steps, 1))
+                yhat = model.predict(x_input, verbose=0)
+                temp_input.extend(yhat[0].tolist())
+
+                lst_output.extend(yhat.tolist())
+                i = i + 1
+
+        print("Output of predicted next steps: ", len(lst_output))
+        """
+        last_days = np.arange(1, time_step_backward + 1)
+        day_pred = np.arange(time_step_backward + 1, time_step_backward + pred_days + 1)
+        print(last_days)
+        print(day_pred)
+
+        temp_mat = np.empty((len(last_days) + pred_days, 1))
+        temp_mat[:] = np.nan
+        """
+        last_original_days_value = temp_mat.copy()
+        next_predicted_days_value = temp_mat.copy()
+        last_original_days_value[0:time_step_backward] = closedf[len(closedf) - time_step_backward:].values
+        next_predicted_days_value[time_step_backward:] = scaler.inverse_transform(np.array(lst_output))
+        """
+        last_original_days_value = temp_mat.copy()
+        next_predicted_days_value_arima = temp_mat.copy()
+        next_predicted_days_value_lstm = temp_mat.copy()
+        if GMDH:
+            next_predicted_days_value_gmdh = temp_mat.copy()
+        if transformer:
+            next_predicted_days_value_transformer = temp_mat.copy()
+
+        last_original_days_value[0:time_step_backward] = \
+            closedf[len(closedf) - time_step_backward:].values
+        next_predicted_days_value_arima[time_step_backward:] = lst_output_arima
+        next_predicted_days_value_lstm[time_step_backward:] = lst_output_lstm
+        if GMDH:
+            next_predicted_days_value_gmdh[time_step_backward:] = lst_output_gmdh
+        if transformer:
+            next_predicted_days_value_transformer[time_step_backward:] = lst_output_transformer
+
+        """
+        new_pred_plot = pd.DataFrame({
+            'last_original_days_value': last_original_days_value.reshape(1, -1).tolist()[0],
+            'next_predicted_days_value': next_predicted_days_value.reshape(1, -1).tolist()[0]
+        })
+        
+
+
+        fig, ax = plt.subplots()
+        ax.plot(new_pred_plot.index, new_pred_plot['last_original_days_value'], label=f"Последние {time_step_backward} шагов цены закратия")
+        ax.plot(new_pred_plot.index, new_pred_plot['next_predicted_days_value'], label=f"Предсказанные следующие {pred_days} шагов цены закрытия")
+        ax.legend()
+        ax.set_title(f"Сравнения последних {time_step_backward} шагов и следующих {pred_days} шагов")
+        st.pyplot(fig)
+        """
+        if GMDH:
+            if transformer:
+                new_pred_plot = pd.DataFrame({
+                    'last_original_days_value': last_original_days_value.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_arima': next_predicted_days_value_arima.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_lstm': next_predicted_days_value_lstm.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_gmdh': next_predicted_days_value_gmdh.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_transformer':
+                        next_predicted_days_value_transformer.reshape(1, -1).tolist()[0]
+                })
+            elif not transformer:
+                new_pred_plot = pd.DataFrame({
+                    'last_original_days_value': last_original_days_value.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_arima': next_predicted_days_value_arima.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_lstm': next_predicted_days_value_lstm.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_gmdh': next_predicted_days_value_gmdh.reshape(1, -1).tolist()[0]
+                })
+        elif not GMDH:
+            if transformer:
+                new_pred_plot = pd.DataFrame({
+                    'last_original_days_value': last_original_days_value.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_arima': next_predicted_days_value_arima.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_lstm': next_predicted_days_value_lstm.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_transformer':
+                        next_predicted_days_value_transformer.reshape(1, -1).tolist()[0]
+                })
+            else:
+                new_pred_plot = pd.DataFrame({
+                    'last_original_days_value': last_original_days_value.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_arima': next_predicted_days_value_arima.reshape(1, -1).tolist()[0],
+                    'next_predicted_days_value_lstm': next_predicted_days_value_lstm.reshape(1, -1).tolist()[0]
+                })
+        fig, ax = plt.subplots()
+        ax.plot(new_pred_plot.index, new_pred_plot['last_original_days_value'],
+                label=f"Последние {time_step_backward} шагов цены закратия")
+        ax.plot(new_pred_plot.index, new_pred_plot['next_predicted_days_value_arima'],
+                label=f"Предсказанные следующие {pred_days} шагов цены закрытия SARIMA")
+        ax.plot(new_pred_plot.index, new_pred_plot['next_predicted_days_value_lstm'],
+                label=f"Предсказанные следующие {pred_days} шагов цены закрытия LSTM")
+        if GMDH:
+            ax.plot(new_pred_plot.index, new_pred_plot['next_predicted_days_value_gmdh'],
+                    label=f"Предсказанные следующие {pred_days} шагов цены закрытия GMDH")
+        if transformer:
+            ax.plot(new_pred_plot.index, new_pred_plot['next_predicted_days_value_transformer'],
+                    label=f"Предсказанные следующие {pred_days} шагов цены закрытия Transformer")
+        ax.legend()
+        ax.set_title(f"Сравнения последних {time_step_backward} шагов и следующих {pred_days} шагов")
+        ax.set_ylim(0, closedf['Close'].max() * 1.5)
+        st.pyplot(fig)
+        #ax.plot()
+
+
+    @st.cache_data
+    def convert_df(df):
+        # IMPORTANT: Cache the conversion to prevent computation on every rerun
+        return df.to_csv().encode("utf-8")
+    @st.cache_data
+    def convert_metrics_df(df):
+        # IMPORTANT: Cache the conversion to prevent computation on every rerun
+        return df.to_csv().encode("utf-8")
+
+    plotdf_csv = convert_df(plotdf)
+    metrics_df_csv = convert_metrics_df(metrics_df)
+    st.download_button('Download data', plotdf_csv, file_name='predictions.csv', mime="text/csv")
+    st.download_button('Download metrics', metrics_df_csv, file_name='metrics.csv', mime="text/csv")
+
+

src/pages/utils/utils.py

@@ -0,0 +1,143 @@
+import numpy as np
+from typing import Literal
+import torch
+from typing import List
+
+def create_dataset(dataset, time_step_backward = 1, time_step_forward = 1):
+    dataX, dataY = [], []
+    for i in range(len(dataset) - time_step_backward - (time_step_forward - 1)):
+        a = dataset[i:(i + time_step_backward), 0]  ###i=0, 0,1,2,3-----99   100
+        dataX.append(a)
+        dataY.append(dataset[i + time_step_backward + (time_step_forward - 1), 0])
+    return np.array(dataX), np.array(dataY)
+
+def make_prediction(X_train: np.ndarray, X_test: np.ndarray,
+                    method: Literal['LSTM', 'GMDH', 'Transformer', 'SARIMA'],
+                    model, scaler, time_step_forward: None) -> np.ndarray:
+    if method == 'LSTM':
+        train_predict = model.predict(X_train)
+        test_predict = model.predict(X_test)
+        train_predict = scaler.inverse_transform(train_predict)
+        test_predict = scaler.inverse_transform(test_predict)
+        return train_predict, test_predict
+    elif method == 'SARIMA':
+        train_predict_arima = []
+        test_predict_arima = []
+        for sample in X_train:
+            train_predict_arima.append(
+                model.fit_predict(sample, n_periods=time_step_forward, return_conf_int=False)[-1])
+        train_predict_arima = np.array(train_predict_arima)
+        for sample in X_test:
+            test_predict_arima.append(
+                model.fit_predict(sample, n_periods=time_step_forward, return_conf_int=False)[-1])
+        test_predict_arima = np.array(test_predict_arima)
+        train_predict_arima = scaler.inverse_transform(train_predict_arima.reshape(-1, 1))
+        test_predict_arima = scaler.inverse_transform(test_predict_arima.reshape(-1, 1))
+        return train_predict_arima, test_predict_arima
+    elif method == 'GMDH':
+        train_predict_gmdh = model.predict(X_train)
+        test_predict_gmdh = model.predict(X_test)
+        train_predict_gmdh = scaler.inverse_transform(train_predict_gmdh.reshape(-1, 1))
+        test_predict_gmdh = scaler.inverse_transform(test_predict_gmdh.reshape(-1, 1))
+        return train_predict_gmdh, test_predict_gmdh
+    elif method == 'Transformer':
+        X_train_context = torch.tensor(X_train)
+        X_test_context = torch.tensor(X_test)
+        X_train_forecast = model.predict(
+            X_train_context,
+            time_step_forward,
+            num_samples=3,
+            temperature=1.0,
+            top_k=50,
+            top_p=1.0)
+        X_test_forecast = model.predict(
+            X_test_context,
+            time_step_forward,
+            num_samples=3,
+            temperature=1.0,
+            top_k=50,
+            top_p=1.0)
+        X_train_forecast_median = np.quantile(X_train_forecast.numpy(), 0.5, axis=1)[:, -1]
+        X_test_forecast_median = np.quantile(X_test_forecast.numpy(), 0.5, axis=1)[:, -1]
+        X_train_forecast_median = scaler.inverse_transform(X_train_forecast_median.reshape(-1, 1))
+        X_test_forecast_median = scaler.inverse_transform(X_test_forecast_median.reshape(-1, 1))
+        return X_train_forecast_median, X_test_forecast_median
+
+
+
+
+
+def make_prediction_recursive(test_data: np.ndarray,
+                              method: Literal['LSTM', 'GMDH', 'Transformer', 'SARIMA'],
+                              model, scaler, pred_days: None, time_step_backward: None) -> List[int]:
+    if method == 'LSTM':
+        x_input_lstm = test_data[len(test_data) - time_step_backward:].reshape(1, -1)
+        temp_input_lstm = list(x_input_lstm)
+        temp_input_lstm = temp_input_lstm[0].tolist()
+        lst_output_lstm = []
+        n_steps = time_step_backward
+        i = 0
+        while (i < pred_days):
+            if (len(temp_input_lstm) > time_step_backward):
+
+                x_input_lstm = np.array(temp_input_lstm[1:])
+                x_input_lstm = x_input_lstm.reshape(1, -1)
+                x_input_lstm = x_input_lstm.reshape((1, n_steps, 1))
+
+                yhat_lstm = model.predict(x_input_lstm, verbose=0)
+                temp_input_lstm.extend(yhat_lstm[0].tolist())
+                temp_input_lstm = temp_input_lstm[1:]
+                lst_output_lstm.extend(yhat_lstm.tolist())
+                i = i + 1
+            else:
+                x_input_lstm = x_input_lstm.reshape((1, n_steps, 1))
+                yhat_lstm = model.predict(x_input_lstm, verbose=0)
+                temp_input_lstm.extend(yhat_lstm[0].tolist())
+                lst_output_lstm.extend(yhat_lstm.tolist())
+                i = i + 1
+
+        lst_output_lstm = scaler.inverse_transform(lst_output_lstm)
+        return lst_output_lstm
+    elif method == 'SARIMA':
+        x_input_arima = test_data[len(test_data) - time_step_backward:]
+        n_steps = time_step_backward
+        lst_output_arima = model.fit_predict(x_input_arima, n_periods=pred_days, return_conf_int=False)  # [-1]
+        lst_output_arima = scaler.inverse_transform(lst_output_arima.reshape(-1, 1))
+        return lst_output_arima
+    elif method == 'GMDH':
+        x_input_gmdh = test_data[len(test_data) - time_step_backward:].reshape(1, -1)
+        temp_input_gmdh = list(x_input_gmdh)
+        temp_input_gmdh = temp_input_gmdh[0].tolist()
+        lst_output_gmdh = []
+        n_steps = time_step_backward
+        i = 0
+        while (i < pred_days):
+            if (len(temp_input_gmdh) > time_step_backward):
+                x_input_gmdh = np.array(temp_input_gmdh[1:])
+                x_input_gmdh = x_input_gmdh.reshape(1, -1)
+                yhat_gmdh = model.predict(x_input_gmdh)
+                temp_input_gmdh.extend(yhat_gmdh.tolist())
+                temp_input_gmdh = temp_input_gmdh[1:]
+                lst_output_gmdh.extend(yhat_gmdh.tolist())
+                i = i + 1
+            else:
+                x_input_gmdh = x_input_gmdh.reshape((1, n_steps, 1))
+                yhat_gmdh = model.predict(x_input_gmdh[0].reshape(1, -1))
+                temp_input_gmdh.extend(yhat_gmdh.tolist())
+                lst_output_gmdh.extend(yhat_gmdh.tolist())
+                i = i + 1
+        lst_output_gmdh = scaler.inverse_transform(np.array(lst_output_gmdh).reshape(-1, 1))
+        return lst_output_gmdh
+    elif method == 'Transformer':
+        x_input_transformer = test_data[len(test_data) - time_step_backward:].reshape(1, -1)
+        x_input_transformer = torch.tensor(x_input_transformer)
+        lst_output_forecast = model.predict(
+            x_input_transformer,
+            pred_days,
+            num_samples=3,
+            temperature=1.0,
+            top_k=50,
+            top_p=1.0)
+        X_train_forecast_median = np.quantile(lst_output_forecast.numpy(), 0.5, axis=1)  # [:, -1]
+        lst_output_transformer = scaler.inverse_transform(X_train_forecast_median.reshape(-1, 1))
+        return lst_output_transformer

src/requirements.txt

@@ -0,0 +1,6 @@
+git+https://github.com/amazon-science/chronos-forecasting.git
+pmdarima
+streamlit
+yfinance
+gmdh
+

src/sidebar_portfolio.py

@@ -0,0 +1,27 @@
+
+
+def sidebar():
+    import streamlit as st
+    #scale_step_type_list = ['Максимизация доходности при заданном уровне риска','Минимизация риска при заданном уровне доходности']
+    #scale_step_type = st.sidebar.selectbox('Оптимизация', scale_step_type_list)
+    scaling_strategy_list = ['average', 'median', 'undersampling']
+    top_n = st.sidebar.number_input('Количество активов-кандидатов', value=5)
+    num_scale_steps = st.sidebar.slider('Горизонт инвестирования, дней', 1, 100, 1)
+    scaling_strategy = st.sidebar.selectbox('Стратегия масштабирования', scaling_strategy_list)
+    target_return_expander = st.sidebar.expander('Задать целевую доходность')
+    target_return = target_return_expander.slider('Уровень доходности, %', 1, 100, None)
+    if target_return:
+        target_return *= 0.01
+    time_step_backward = st.sidebar.slider('Количество предикторов, дней', 1, 100, 15)
+    allow_short = st.sidebar.checkbox('Разрешить короткие позиции')
+
+
+    scaling_strategy = 'average'
+    time_step_backward = 15
+    return {'top_n': top_n,
+            'num_scale_steps': num_scale_steps,
+            'scaling_strategy': scaling_strategy,
+            'target_return': target_return,
+            'time_step_backward': time_step_backward, 
+            'allow_short': allow_short}
+