i have following code to train a lstm model:

# %% [markdown]
# <a href="https://colab.research.google.com/github/034adarsh/Stock-Price-Prediction-Using-LSTM/blob/main/LSTM_Improved_model(diff_dataset).ipynb" target="_parent"><img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/></a>

# %% [markdown]
# # Import all the required libraries
# 
# ---
# 
# 

# %%
import pandas as pd
import datetime as dt
from datetime import date
import numpy as np
import tensorflow as tf

# %% [markdown]
# # Define start day to fetch the dataset from the yahoo finance library
# 
# ---
# 
# 

# %%
data = pd.read_csv(r'C:\Users\arisa\Desktop\ddd\Binance_AVAXUSDT_d.csv')
df=data
df.head()

# %%

df = df[["Open", "High", "Low", "Close","volume_base", "volume_crypto", "tradecount","y1","y2","y3"]]
data = data[["Open", "High", "Low", "Close","volume_base", "volume_crypto", "tradecount","y1","y2","y3"]]
df.head()

# %% [markdown]
# Visualizing Closing Price

# %%
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 6))
plt.plot(df['Close'])
plt.title("TCS India Stock Price")
plt.xlabel("Date")
plt.ylabel("Price (INR)")
plt.grid(True)
plt.show()

# %%
df

# %% [markdown]
# # Plotting moving averages of 100 day
# 
# ---
# 
# 

# %%
ma100 = df.Close.rolling(100).mean()
ma100

# %%
plt.figure(figsize = (12,6))
plt.plot(df.Close)
plt.plot(ma100, 'r')
plt.grid(True)
plt.title('Graph Of Moving Averages Of 100 Days')

# %% [markdown]
# # Defining 200 days moving averages and plotting comparision graph with 100 days moving averages
# 
# ---
# 
# 

# %%
ma200 = df.Close.rolling(200).mean()
ma200

# %%
plt.figure(figsize = (12,6))
plt.plot(df.Close)
plt.plot(ma100, 'r')
plt.plot(ma200, 'g')
plt.grid(True)
plt.title('Comparision Of 100 Days And 200 Days Moving Averages')

# %%
df.shape

# %% [markdown]
# # Spliting the dataset into training (70%) and testing (30%) set

# %%
# Splitting data into training and testing

train = pd.DataFrame(data[0:int(len(data)*0.70)])
test = pd.DataFrame(data[int(len(data)*0.70): int(len(data))])

print(train.shape)
print(test.shape)

# %%
train.head()

# %%
test.head()

# %% [markdown]
# # Using MinMax scaler for normalization of the dataset
# 
# ---
# 
# 

# %%
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler(feature_range=(0,1))

# %%
train_close = train.iloc[:, 4:5].values
test_close = test.iloc[:, 4:5].values

# %%
data_training_array = scaler.fit_transform(train_close)
data_training_array

# %%
x_train = []
y_train = [] 

for i in range(100, data_training_array.shape[0]):
    x_train.append(data_training_array[i-100: i])
    y_train.append(data_training_array[i, 0])

x_train, y_train = np.array(x_train), np.array(y_train) 

# %%
x_train.shape

# %% [markdown]
# # ML Model (LSTM)
# 
# ---
# 
# 

# %%
from tensorflow.keras.layers import Dense, Dropout, LSTM
from tensorflow.keras.models import Sequential

# %%
model = Sequential()
model.add(LSTM(units = 50, activation = 'tanh', return_sequences=True
              ,input_shape = (x_train.shape[1], 1)))
model.add(Dropout(0.2))


model.add(LSTM(units = 60, activation = 'tanh', return_sequences=True))
model.add(Dropout(0.3))


model.add(LSTM(units = 80, activation = 'tanh', return_sequences=True))
model.add(Dropout(0.4))


model.add(LSTM(units = 120, activation = 'tanh'))
model.add(Dropout(0.5))

model.add(Dense(units = 1))

# %%
model.summary()

# %% [markdown]
# # Training the model
# 
# ---
# 
# 

# %%
import tensorflow as tf
model.compile(optimizer = 'adam', loss = 'mean_squared_error', metrics=[tf.keras.metrics.MeanAbsoluteError()])
model.fit(x_train, y_train,epochs = 100)

# %%
model.save('keras_model.h5')

# %%
test_close.shape

# %%
past_100_days = pd.DataFrame(train_close[-100:])

# %%
test_df = pd.DataFrame(test_close)

# %% [markdown]
# **Defining the final dataset for testing by including last 100 coloums of the training dataset to get the prediction from the 1st column of the testing dataset.**
# 
# ---
# 

# %%
final_df = past_100_days._append(test_df, ignore_index = True)

# %%
final_df.head()

# %%
input_data = scaler.fit_transform(final_df)
input_data

# %%
input_data.shape

# %% [markdown]
# # Testing the model
# 
# ---
# 
# 

# %%
x_test = []
y_test = []
for i in range(100, input_data.shape[0]):
   x_test.append(input_data[i-100: i])
   y_test.append(input_data[i, 0])

# %%
x_test, y_test = np.array(x_test), np.array(y_test)
print(x_test.shape)
print(y_test.shape)

# %% [markdown]
# # Making prediction and plotting the graph of predicted vs actual values
# 
# ---
# 
# 

# %%
# Making predictions

y_pred = model.predict(x_test)

# %%
y_pred.shape

# %%
y_test

# %%
y_pred

# %%
scaler.scale_

# %%
scale_factor = 1/0.00041967
y_pred = y_pred * scale_factor
y_test = y_test * scale_factor

# %%
plt.figure(figsize = (12,6))
plt.plot(y_test, 'b', label = "Original Price")
plt.plot(y_pred, 'r', label = "Predicted Price")
plt.xlabel('Time')
plt.ylabel('Price')
plt.legend()
plt.grid(True)
plt.show()

# %% [markdown]
# # Model evaluation

# %% [markdown]
# Calculation of mean absolute error

# %%
from sklearn.metrics import mean_absolute_error

mae = mean_absolute_error(y_test, y_pred)
mae_percentage = (mae / np.mean(y_test)) * 100
print("Mean absolute error on test set: {:.2f}%".format(mae_percentage))

# %% [markdown]
# Calculation of R2 score

# %%
from sklearn.metrics import r2_score

# Actual values
actual = y_test

# Predicted values
predicted = y_pred

# Calculate the R2 score
r2 = r2_score(actual, predicted)

print("R2 score:", r2)

# %%
# Plotting the R2 score
fig, ax = plt.subplots()
ax.barh(0, r2, color='skyblue')
ax.set_xlim([-1, 1])
ax.set_yticks([])
ax.set_xlabel('R2 Score')
ax.set_title('R2 Score')

# Adding the R2 score value on the bar
ax.text(r2, 0, f'{r2:.2f}', va='center', color='black')

plt.show()

# %%
plt.scatter(actual, predicted)
plt.plot([min(actual), max(actual)], [min(predicted), max(predicted)], 'r--')
plt.xlabel('Actual Values')
plt.ylabel('Predicted Values')
plt.title(f'R2 Score: {r2:.2f}')
plt.show()





make proper changes so the model uses "Open", "High", "Low", "Close","volume_base", "volume_crypto", "tradecount" instead of just using "Close" and also  predicts "y1","y2","y3" instead of just Close price