Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· OpenAIAi2 WildChat-4.8M (AI2)

Please modify this code for making prediction of next 5 days (use this code as starting…

  1. User

    Please modify this code for making prediction of next 5 days (use this code as starting point you can modify any function or make any new function):

    import numpy as np import pandas as pd import matplotlib.pyplot as plt import yfinance as yf from sklearn.preprocessing import MinMaxScaler from keras.models import Sequential from keras.layers import Dense, LSTM, Dropout

    def calculate_atr(data, period): data['h-l'] = data['high'] - data['low'] data['h-pc'] = abs(data['high'] - data['close'].shift(1)) data['l-pc'] = abs(data['low'] - data['close'].shift(1)) data['tr'] = data[['h-l', 'h-pc', 'l-pc']].max(axis=1) data['atr'] = data['tr'].rolling(window=period).mean() return data

    def calculate_super_trend(data, period, multiplier): data = calculate_atr(data, period) data['Upper Basic'] = (data['high'] + data['low']) / 2 + multiplier * data['atr'] data['Lower Basic'] = (data['high'] + data['low']) / 2 - multiplier * data['atr'] data['Upper Band'] = data.apply(lambda x: x['Upper Basic'] if x['close'] > x['Upper Basic'] else x['Lower Basic'], axis=1) data['Lower Band'] = data.apply(lambda x: x['Lower Basic'] if x['close'] < x['Lower Basic'] else x['Upper Basic'], axis=1) data['Super Trend'] = np.where(data['close'] > data['Upper Band'], data['Lower Band'], data['Upper Band']) return data.dropna()

    def load_preprocess_data(ticker, start_date, end_date, window_size, period=14, multiplier=3): stock_data = yf.download(ticker, start=start_date, end=end_date) print("Original columns:", stock_data.columns) stock_data.columns = [col.lower() for col in stock_data.columns] stock_data_with_super_trend = calculate_super_trend(stock_data, period, multiplier)

    columns_to_use = stock_data_with_super_trend[['open', 'high', 'low', 'close', 'Super Trend']].values
    scaler = MinMaxScaler(feature_range=(0, 1))
    data_normalized = scaler.fit_transform(columns_to_use)
    
    X, y = [], []
    for i in range(window_size, len(data_normalized)):
        X.append(data_normalized[i - window_size:i])
        y.append(data_normalized[i, 3]) # Use Close prices directly as labels
    
    train_len = int(0.8 * len(X))
    X_train, y_train = np.array(X[:train_len]), np.array(y[:train_len])
    X_test, y_test = np.array(X[train_len:]), np.array(y[train_len:])
    
    return X_train, y_train, X_test, y_test
    

    def create_lstm_model(input_shape): model = Sequential() model.add(LSTM(units=50, return_sequences=True, input_shape=input_shape)) model.add(LSTM(units=50, return_sequences=True)) model.add(LSTM(units=50)) model.add(Dense(units=1))

    model.compile(optimizer='adam', loss='mean_squared_error')
    return model
    

    def train_model(model, X_train, y_train, batch_size, epochs): history = model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_split=0.1) return model, history

    def evaluate_model(model, X_test, y_test, scaler): y_pred = model.predict(X_test) y_pred_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_pred.shape), y_pred)))[:, 1] # Inverse transform for Close prices y_test_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_test.shape), y_test)))[:, 1]

    mae = np.mean(np.abs(y_pred_inverse - y_test_inverse))
    mse = np.mean(np.square(y_pred_inverse - y_test_inverse))
    return mae, mse
    

    def plot_prediction(model, X_test, y_test, scaler): y_pred = model.predict(X_test) y_pred_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_pred.shape), y_pred)))[:, 1] # Inverse transform for Close prices y_test_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_test.shape), y_test)))[:, 1]

    plt.figure(figsize=(14, 6))
    plt.plot(y_test_inverse, label='Actual')
    plt.plot(y_pred_inverse, label='Predicted')
    plt.xlabel('Days')
    plt.ylabel('Close Price')
    plt.title('Stock Price Prediction (Actual vs Predicted)')
    plt.legend()
    plt.show()
    

    Define the parameters

    ticker = '^NSEI' # Ticker symbol for Nifty start_date = '2010-01-01' end_date = '2023-06-01' window_size = 40 # Number of previous days' data to consider period = 14 # ATR period multiplier = 3 # ATR multiplier batch_size = 32 epochs = 100

    X_train, y_train, X_test, y_test = load_preprocess_data(ticker, start_date, end_date, window_size, period, multiplier)

    Create the LSTM model

    input_shape = (X_train.shape[1], X_train.shape[2]) model = create_lstm_model(input_shape)

    Train the model

    model, history = train_model(model, X_train, y_train, batch_size, epochs)

    scaler = MinMaxScaler(feature_range=(0, 1)) scaler.fit_transform(y_train.reshape(-1, 1)) mae, mse = evaluate_model(model, X_test, y_test, scaler) print(f"Mean Absolute Error: {mae}") print(f"Mean Squared Error: {mse}")

    Plot the predictions

    plot_prediction(model, X_test, y_test, scaler)

  2. Assistant

    Here's the updated code for making predictions for the next 5 days:

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    import yfinance as yf
    from sklearn.preprocessing import MinMaxScaler
    from keras.models import Sequential
    from keras.layers import Dense, LSTM, Dropout
    
    def calculate_atr(data, period):
        data['h-l'] = data['high'] - data['low']
        data['h-pc'] = abs(data['high'] - data['close'].shift(1))
        data['l-pc'] = abs(data['low'] - data['close'].shift(1))
        data['tr'] = data[['h-l', 'h-pc', 'l-pc']].max(axis=1)
        data['atr'] = data['tr'].rolling(window=period).mean()
        return data
    
    def calculate_super_trend(data, period, multiplier):
        data = calculate_atr(data, period)
        data['Upper Basic'] = (data['high'] + data['low']) / 2 + multiplier * data['atr']
        data['Lower Basic'] = (data['high'] + data['low']) / 2 - multiplier * data['atr']
        data['Upper Band'] = data.apply(lambda x: x['Upper Basic'] if x['close'] > x['Upper Basic'] else x['Lower Basic'], axis=1)
        data['Lower Band'] = data.apply(lambda x: x['Lower Basic'] if x['close'] < x['Lower Basic'] else x['Upper Basic'], axis=1)
        data['Super Trend'] = np.where(data['close'] > data['Upper Band'], data['Lower Band'], data['Upper Band'])
        return data.dropna()
    
    def load_preprocess_data(ticker, start_date, end_date, window_size, period=14, multiplier=3):
        stock_data = yf.download(ticker, start=start_date, end=end_date)
        print("Original columns:", stock_data.columns)
        stock_data.columns = [col.lower() for col in stock_data.columns]
        stock_data_with_super_trend = calculate_super_trend(stock_data, period, multiplier)
    
        columns_to_use = stock_data_with_super_trend[['open', 'high', 'low', 'close', 'Super Trend']].values
        scaler = MinMaxScaler(feature_range=(0, 1))
        data_normalized = scaler.fit_transform(columns_to_use)
    
        X, y = [], []
        for i in range(window_size, len(data_normalized)):
            X.append(data_normalized[i - window_size:i])
            y.append(data_normalized[i, 3]) # Use Close prices directly as labels
    
        train_len = int(0.8 * len(X))
        X_train, y_train = np.array(X[:train_len]), np.array(y[:train_len])
        X_test, y_test = np.array(X[train_len:]), np.array(y[train_len:])
    
        return X_train, y_train, X_test, y_test
    
    def create_lstm_model(input_shape):
        model = Sequential()
        model.add(LSTM(units=50, return_sequences=True, input_shape=input_shape))
        model.add(LSTM(units=50, return_sequences=True))
        model.add(LSTM(units=50))
        model.add(Dense(units=1))
    
        model.compile(optimizer='adam', loss='mean_squared_error')
        return model
    
    def train_model(model, X_train, y_train, batch_size, epochs):
        history = model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_split=0.1)
        return model, history
    
    def evaluate_model(model, X_test, y_test, scaler):
        y_pred = model.predict(X_test)
        y_pred_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_pred.shape), y_pred)))[:, 1] # Inverse transform for Close prices
        y_test_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_test.shape), y_test)))[:, 1]
    
        mae = np.mean(np.abs(y_pred_inverse - y_test_inverse))
        mse = np.mean(np.square(y_pred_inverse - y_test_inverse))
        return mae, mse
    
    def plot_prediction(model, X_test, y_test, scaler):
        y_pred = model.predict(X_test)
        y_pred_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_pred.shape), y_pred)))[:, 1] # Inverse transform for Close prices
        y_test_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_test.shape), y_test)))[:, 1]
    
        plt.figure(figsize=(14, 6))
        plt.plot(y_test_inverse, label='Actual')
        plt.plot(y_pred_inverse, label='Predicted')
        plt.xlabel('Days')
        plt.ylabel('Close Price')
        plt.title('Stock Price Prediction (Actual vs Predicted)')
        plt.legend()
        plt.show()
    
    def predict_next_5_days(model, data_normalized, window_size, scaler):
        last_window = data_normalized[-window_size:]
        future_pred = []
        for _ in range(5):
            pred = model.predict(last_window.reshape(1, window_size, -1))
            future_pred.append(pred.ravel()[0])
            last_window = np.roll(last_window, -1, axis=0)
            last_window[-1, 3] = pred
    
        future_pred_inverse = scaler.inverse_transform(np.column_stack((np.zeros((5, 4)), future_pred)))[:, -1]
        return future_pred_inverse
    
    # Define the parameters
    ticker = '^NSEI'  # Ticker symbol for Nifty
    start_date = '2010-01-01'
    end_date = '2023-06-01'
    window_size = 40  # Number of previous days' data to consider
    period = 14  # ATR period
    multiplier = 3  # ATR multiplier
    batch_size = 32
    epochs = 100
    
    X_train, y_train, X_test, y_test = load_preprocess_data(ticker, start_date, end_date, window_size, period, multiplier)
    
    # Create the LSTM model
    input_shape = (X_train.shape[1], X_train.shape[2])
    model = create_lstm_model(input_shape)
    
    # Train the model
    model, history = train_model(model, X_train, y_train, batch_size, epochs)
    
    # Evaluate the model
    scaler = MinMaxScaler(feature_range=(0, 1))
    data_normalized = scaler.fit_transform(X_train.reshape(-1, 1))
    mae, mse = evaluate_model(model, X_test, y_test, scaler)
    print(f"Mean Absolute Error: {mae}")
    print(f"Mean Squared Error: {mse}")
    
    # Plot the predictions
    plot_prediction(model, X_test, y_test, scaler)
    
    # Predict the next 5 days
    next_5_days_pred = predict_next_5_days(model, data_normalized, window_size, scaler)
    print("Next 5 days predictions:", next_5_days_pred)
    

    This code introduces a new function, predict_next_5_days(), which takes the trained model, the normalized data, the window size, and the scaler. It makes predictions for the next 5 days and returns the inverse-transformed close prices. The function is called at the end of the script to make predictions.

  3. User

    How to overcome this error in the code: Error:

    IndexError Traceback (most recent call last) in <cell line: 2>() 1 # Predict the next 5 days ----> 2 next_5_days_pred = predict_next_5_days(model, data_normalized, window_size, scaler) 3 print("Next 5 days predictions:", next_5_days_pred)

    in predict_next_5_days(model, data_normalized, window_size, scaler) 6 future_pred.append(pred.ravel()[0]) 7 last_window = np.roll(last_window, -1, axis=0) ----> 8 last_window[-1, 3] = pred 9 10 future_pred_inverse = scaler.inverse_transform(np.column_stack((np.zeros((5, 4)), future_pred)))[:, -1]

    IndexError: index 3 is out of bounds for axis 1 with size 1

    Code: import numpy as np import pandas as pd import matplotlib.pyplot as plt import yfinance as yf from sklearn.preprocessing import MinMaxScaler from keras.models import Sequential from keras.layers import Dense, LSTM, Dropout

    def calculate_atr(data, period): data['h-l'] = data['high'] - data['low'] data['h-pc'] = abs(data['high'] - data['close'].shift(1)) data['l-pc'] = abs(data['low'] - data['close'].shift(1)) data['tr'] = data[['h-l', 'h-pc', 'l-pc']].max(axis=1) data['atr'] = data['tr'].rolling(window=period).mean() return data

    def calculate_super_trend(data, period, multiplier): data = calculate_atr(data, period) data['Upper Basic'] = (data['high'] + data['low']) / 2 + multiplier * data['atr'] data['Lower Basic'] = (data['high'] + data['low']) / 2 - multiplier * data['atr'] data['Upper Band'] = data.apply(lambda x: x['Upper Basic'] if x['close'] > x['Upper Basic'] else x['Lower Basic'], axis=1) data['Lower Band'] = data.apply(lambda x: x['Lower Basic'] if x['close'] < x['Lower Basic'] else x['Upper Basic'], axis=1) data['Super Trend'] = np.where(data['close'] > data['Upper Band'], data['Lower Band'], data['Upper Band']) return data.dropna()

    def load_preprocess_data(ticker, start_date, end_date, window_size, period=14, multiplier=3): stock_data = yf.download(ticker, start=start_date, end=end_date) print("Original columns:", stock_data.columns) stock_data.columns = [col.lower() for col in stock_data.columns] stock_data_with_super_trend = calculate_super_trend(stock_data, period, multiplier)

    columns_to_use = stock_data_with_super_trend[['open', 'high', 'low', 'close', 'Super Trend']].values
    scaler = MinMaxScaler(feature_range=(0, 1))
    data_normalized = scaler.fit_transform(columns_to_use)
    
    X, y = [], []
    for i in range(window_size, len(data_normalized)):
        X.append(data_normalized[i - window_size:i])
        y.append(data_normalized[i, 3]) # Use Close prices directly as labels
    
    train_len = int(0.8 * len(X))
    X_train, y_train = np.array(X[:train_len]), np.array(y[:train_len])
    X_test, y_test = np.array(X[train_len:]), np.array(y[train_len:])
    
    return X_train, y_train, X_test, y_test
    

    def create_lstm_model(input_shape): model = Sequential() model.add(LSTM(units=50, return_sequences=True, input_shape=input_shape)) model.add(LSTM(units=50, return_sequences=True)) model.add(LSTM(units=50)) model.add(Dense(units=1))

    model.compile(optimizer='adam', loss='mean_squared_error')
    return model
    

    def train_model(model, X_train, y_train, batch_size, epochs): history = model.fit(X_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_split=0.1) return model, history

    def evaluate_model(model, X_test, y_test, scaler): y_pred = model.predict(X_test) y_pred_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_pred.shape), y_pred)))[:, 1] # Inverse transform for Close prices y_test_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_test.shape), y_test)))[:, 1]

    mae = np.mean(np.abs(y_pred_inverse - y_test_inverse))
    mse = np.mean(np.square(y_pred_inverse - y_test_inverse))
    return mae, mse
    

    def plot_prediction(model, X_test, y_test, scaler): y_pred = model.predict(X_test) y_pred_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_pred.shape), y_pred)))[:, 1] # Inverse transform for Close prices y_test_inverse = scaler.inverse_transform(np.column_stack((np.zeros(y_test.shape), y_test)))[:, 1]

    plt.figure(figsize=(14, 6))
    plt.plot(y_test_inverse, label='Actual')
    plt.plot(y_pred_inverse, label='Predicted')
    plt.xlabel('Days')
    plt.ylabel('Close Price')
    plt.title('Stock Price Prediction (Actual vs Predicted)')
    plt.legend()
    plt.show()
    

    Define the parameters

    ticker = '^NSEI' # Ticker symbol for Nifty start_date = '2010-01-01' end_date = '2023-06-01' window_size = 40 # Number of previous days' data to consider period = 14 # ATR period multiplier = 3 # ATR multiplier batch_size = 32 epochs = 100

    X_train, y_train, X_test, y_test = load_preprocess_data(ticker, start_date, end_date, window_size, period, multiplier)

    Create the LSTM model

    input_shape = (X_train.shape[1], X_train.shape[2]) model = create_lstm_model(input_shape)

    Train the model

    model, history = train_model(model, X_train, y_train, batch_size, epochs)

    Evaluate the model

    scaler = MinMaxScaler(feature_range=(0, 1)) data_normalized = scaler.fit_transform(X_train.reshape(-1, 1)) mae, mse = evaluate_model(model, X_test, y_test, scaler) print(f"Mean Absolute Error: {mae}") print(f"Mean Squared Error: {mse}")

    Plot the predictions

    plot_prediction(model, X_test, y_test, scaler)

    def predict_next_5_days(model, data_normalized, window_size, scaler): last_window = data_normalized[-window_size:] future_pred = [] for _ in range(5): pred = model.predict(last_window.reshape(1, window_size, -1)) future_pred.append(pred.ravel()[0]) last_window = np.roll(last_window, -1, axis=0) last_window[-1, 3] = pred

    future_pred_inverse = scaler.inverse_transform(np.column_stack((np.zeros((5, 4)), future_pred)))[:, -1]
    return future_pred_inverse
    

    Predict the next 5 days

    next_5_days_pred = predict_next_5_days(model, data_normalized, window_size, scaler) print("Next 5 days predictions:", next_5_days_pred)

  4. Assistant

    I apologize for the confusion earlier. There is a mistake in the predict_next_5_days() function. It should use the previously normalized data data_normalized with all features, not just the X_train. The error was caused by an incorrect index passed to last_window when updating the close price. Here is the corrected predict_next_5_days() function and the implementation:

    def predict_next_5_days(model, data_normalized, window_size, scaler):
        last_window = data_normalized[-window_size:]
        future_pred = []
        for _ in range(5):
            pred = model.predict(last_window.reshape(1, window_size, -1))
            future_pred.append(pred.ravel()[0])
            last_window = np.roll(last_window, -1, axis=0)
            last_window[-1, 3] = pred
    
        future_pred_scaled = scaler.inverse_transform(np.column_stack((np.zeros((5, data_normalized.shape[1] - 1)), future_pred)))[:, -1]
        return future_pred_scaled
    
    # Define the parameters
    ticker = '^NSEI'  # Ticker symbol for Nifty
    start_date = '2010-01-01'
    end_date = '2023-06-01'
    window_size = 40  # Number of previous days' data to consider
    period = 14  # ATR period
    multiplier = 3  # ATR multiplier
    batch_size = 32
    epochs = 100
    
    X_train, y_train, X_test, y_test = load_preprocess_data(ticker, start_date, end_date, window_size, period, multiplier)
    
    # Create the LSTM model
    input_shape = (X_train.shape[1], X_train.shape[2])
    model = create_lstm_model(input_shape)
    
    # Train the model
    model, history = train_model(model, X_train, y_train, batch_size, epochs)
    
    # Evaluate the model
    scaler = MinMaxScaler(feature_range=(0, 1))
    data_normalized_cols = load_preprocess_data(ticker, start_date, end_date, window_size, period, multiplier)[2]  # Reusing the scaler for the inverse_transform
    data_normalized = scaler.fit_transform(data_normalized_cols)
    
    mae, mse = evaluate_model(model, X_test, y_test, scaler)
    print(f"Mean Absolute Error: {mae}")
    print(f"Mean Squared Error: {mse}")
    
    # Plot the predictions
    plot_prediction(model, X_test, y_test, scaler)
    
    # Predict the next 5 days
    next_5_days_pred = predict_next_5_days(model, data_normalized, window_size, scaler)
    print("Next 5 days predictions:", next_5_days_pred)
    

    Now, the predict_next_5_days() function will work correctly, and the error should be resolved.

  5. User

    ValueError Traceback (most recent call last) in <cell line: 35>() 33 scaler = MinMaxScaler(feature_range=(0, 1)) 34 data_normalized_cols = load_preprocess_data(ticker, start_date, end_date, window_size, period, multiplier)[2] # Reusing the scaler for the inverse_transform ---> 35 data_normalized = scaler.fit_transform(data_normalized_cols) 36 37 mae, mse = evaluate_model(model, X_test, y_test, scaler)

    5 frames /usr/local/lib/python3.10/dist-packages/sklearn/utils/validation.py in check_array(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator, input_name) 913 ) 914 if not allow_nd and array.ndim >= 3: --> 915 raise ValueError( 916 "Found array with dim %d. %s expected <= 2." 917 % (array.ndim, estimator_name)

    ValueError: Found array with dim 3. MinMaxScaler expected <= 2.

  6. Assistant

    Apologies again for the confusion. The issue is caused because we are passing a 3D array to the scaler while it expects a 2D array. Please use the following updated code that corrects the scaler's input:

    def predict_next_5_days(model, data_normalized, window_size, scaler):
        last_window = data_normalized[-window_size:]
        future_pred = []
        for _ in range(5):
            pred = model.predict(last_window.reshape(1, window_size, -1))
            future_pred.append(pred.ravel()[0])
            last_window = np.roll(last_window, -1, axis=0)
            last_window[-1, 3] = pred
    
        future_pred_scaled = scaler.inverse_transform(np.column_stack((np.zeros((5, data_normalized.shape[1] - 1)), future_pred)))[:, -1]
        return future_pred_scaled
    
    # ....
    
    scaler = MinMaxScaler(feature_range=(0, 1))
    data_normalized_temp = load_preprocess_data(ticker, start_date, end_date, window_size, period, multiplier)
    data_normalized_cols = np.vstack((data_normalized_temp[0].reshape(-1, data_normalized_temp[0].shape[2]), data_normalized_temp[2].reshape(-1, data_normalized_temp[2].shape[2])))
    data_normalized = scaler.fit_transform(data_normalized_cols)
    
    # ....
    
    # Predict the next 5 days
    next_5_days_pred = predict_next_5_days(model, data_normalized.reshape(-1, data_normalized_temp[0].shape[1], data_normalized_temp[0].shape[2]), window_size, scaler)
    print("Next 5 days predictions:", next_5_days_pred)
    

    This change modifies the data_normalized_cols input for the scaler, stacking the reshaped X_train and X_test arrays (making them 2D) to fit and transform with the scaler in a 2D format. The predict_next_5_days() function now takes the correctly normalized 3D array as input.

  7. User

    ValueError Traceback (most recent call last) in <cell line: 36>() 34 data_normalized = scaler.fit_transform(data_normalized_cols) 35 ---> 36 mae, mse = evaluate_model(model, X_test, y_test, scaler) 37 print(f"Mean Absolute Error: {mae}") 38 print(f"Mean Squared Error: {mse}")

    1 frames /usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/data.py in inverse_transform(self, X) 539 ) 540 --> 541 X -= self.min 542 X /= self.scale_ 543 return X

    ValueError: operands could not be broadcast together with shapes (648,2) (5,) (648,2)

  8. Assistant

    I apologize for any confusion caused. I made an error while concatenating the arrays in the data_normalized_cols variable. Here's the corrected portion of the code:

    def predict_next_5_days(model, data_normalized, window_size, scaler):
        last_window = data_normalized[-window_size:]
        future_pred = []
        for _ in range(5):
            pred = model.predict(last_window.reshape(1, window_size, -1))
            future_pred.append(pred.ravel()[0])
            last_window = np.roll(last_window, -1, axis=0)
            last_window[-1, 3] = pred
    
        future_pred_scaled = scaler.inverse_transform(np.column_stack((np.zeros((5, data_normalized.shape[1] - 1)), future_pred)))[:, -1]
        return future_pred_scaled
    
    # ....
    
    scaler_full = MinMaxScaler(feature_range=(0, 1))
    data_normalized_temp = load_preprocess_data(ticker, start_date, end_date, window_size, period, multiplier)
    data_normalized_cols = np.vstack((data_normalized_temp[0].reshape(-1, data_normalized_temp[0].shape[2]), 
                                      data_normalized_temp[2].reshape(-1, data_normalized_temp[2].shape[2])))
    data_normalized = scaler_full.fit_transform(data_normalized_cols)
    
    # ....
    
    # Evaluate the model
    mae, mse = evaluate_model(model, X_test, y_test, scaler_full)
    print(f"Mean Absolute Error: {mae}")
    print(f"Mean Squared Error: {mse}")
    
    # Predict the next 5 days
    next_5_days_pred = predict_next_5_days(model, data_normalized.reshape(-1, data_normalized_temp[0].shape[1], 
                                                                          data_normalized_temp[0].shape[2]), 
                                           window_size, scaler_full)
    print("Next 5 days predictions:", next_5_days_pred)
    

    In this updated version, I have corrected the scaler variable, creating a new scaler_full instance for the full dataset (data_normalized_cols), which is now used in the evaluate_model() and predict_next_5_days() functions. This should resolve the error.