How to overcome this error:
ERROR:
Epoch 1/200
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-59-a2314fc7168e> in <cell line: 15>()
     13 model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
     14 
---> 15 model.fit(X_train, y_train, epochs=200, verbose=1)

1 frames
/usr/local/lib/python3.10/dist-packages/keras/engine/training.py in tf__train_function(iterator)
     13                 try:
     14                     do_return = True
---> 15                     retval_ = ag__.converted_call(ag__.ld(step_function), (ag__.ld(self), ag__.ld(iterator)), None, fscope)
     16                 except:
     17                     do_return = False

ValueError: in user code:

    File "/usr/local/lib/python3.10/dist-packages/keras/engine/training.py", line 1284, in train_function  *
        return step_function(self, iterator)
    File "/usr/local/lib/python3.10/dist-packages/keras/engine/training.py", line 1268, in step_function  **
        outputs = model.distribute_strategy.run(run_step, args=(data,))
    File "/usr/local/lib/python3.10/dist-packages/keras/engine/training.py", line 1249, in run_step  **
        outputs = model.train_step(data)
    File "/usr/local/lib/python3.10/dist-packages/keras/engine/training.py", line 1050, in train_step
        y_pred = self(x, training=True)
    File "/usr/local/lib/python3.10/dist-packages/keras/utils/traceback_utils.py", line 70, in error_handler
        raise e.with_traceback(filtered_tb) from None
    File "/usr/local/lib/python3.10/dist-packages/keras/engine/input_spec.py", line 298, in assert_input_compatibility
        raise ValueError(

    ValueError: Input 0 of layer "sequential_4" is incompatible with the layer: expected shape=(None, 100, 8), found shape=(None, 8)

Code:
import yfinance as yf
import pandas as pd
import numpy as np

nifty_df = yf.download('^NSEI', start='2009-01-01', end='2021-12-31')

# Clean the data
nifty_df = nifty_df.dropna()

# Calculate various percent differences
nifty_df['PctOpenClose'] = (nifty_df['Close'] - nifty_df['Open']) / nifty_df['Open'] * 100
nifty_df['PctHighLow'] = (nifty_df['High'] - nifty_df['Low']) / nifty_df['Low'] * 100
nifty_df['PctChange'] = nifty_df['Close'].pct_change() * 100

# Remove the first row with NaN in 'PctChange'
nifty_df = nifty_df.iloc[1:]

# Export cleaned dataset
nifty_df.to_csv('nifty_cleaned.csv')

def create_labels(df, col_name, threshold=0.5):
    labels = []
    for index, row in df.iterrows():
        future_price = row[col_name]
        if future_price >= threshold:
            labels.append(1)    # Buy
        elif future_price <= -threshold:
            labels.append(-1)   # Sell
        else:
            labels.append(0)    # Hold

    return labels

nifty_df['Labels'] = create_labels(nifty_df, 'PctChange')

import matplotlib.pyplot as plt
import seaborn as sns

sns.countplot(nifty_df['Labels'])

plt.title('Count of Buy, Hold, and Sell')
plt.xlabel('Trade Decisions')
plt.ylabel('Count')
plt.show()

from sklearn.ensemble import ExtraTreesClassifier

X = nifty_df.drop(['Labels'], axis=1)
y = nifty_df['Labels']

# Fit the ExtraTreesClassifier
et_clf = ExtraTreesClassifier()
et_clf.fit(X, y)

# Visualize feature importances
feature_importances = pd.Series(et_clf.feature_importances_, index=X.columns)
feature_importances.nlargest(10).plot(kind='barh')
plt.show()


important_features = feature_importances.nlargest(8).index.tolist()
X_filtered = X[important_features]
X_filtered

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
scaled_X = scaler.fit_transform(X_filtered)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(scaled_X, y, test_size=0.2, random_state=42)

from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout

look_back = 100

def create_dataset(X, y, look_back=100):
    dataX, dataY = [], []
    for i in range(len(X)-look_back-1):
        dataX.append(X[i:(i+look_back), :])
        dataY.append(y[i + look_back])
    return np.array(dataX), np.array(dataY)

X_train_lstm, y_train_lstm = create_dataset(X_train, y_train, look_back)
X_test_lstm, y_test_lstm = create_dataset(X_test, y_test, look_back)


from keras.models import Sequential
from keras.layers import LSTM, Dense

model = Sequential()
model.add(LSTM(100, activation='relu', return_sequences=True, input_shape=(look_back, 8)))
model.add(Dropout(0.2))
model.add(LSTM(100, activation='relu', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(100, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(3, activation='softmax'))

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

model.fit(X_train, y_train, epochs=200, verbose=1)

from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, accuracy_score

y_pred = model.predict(X_test_lstm)

y_pred_labels = np.argmax(y_pred, axis=1) - 1

print("Confusion Matrix:")
print(confusion_matrix(y_test_lstm, y_pred_labels))

print("\n Evaluation Metrics:")
print("Accuracy: ", accuracy_score(y_test_lstm, y_pred_labels))
print("Precision: ", precision_score(y_test_lstm, y_pred_labels, average='macro'))
print("Recall: ", recall_score(y_test_lstm, y_pred_labels, average='macro'))
print("F1-Score: ", f1_score(y_test_lstm, y_pred_labels, average='macro'))

model.save('nifty_lstm_model.h5') 

# Import the necessary libraries
from keras.models import load_model

# Load the trained model
trained_model = load_model('nifty_lstm_model.h5')

# Load the new dataset for prediction
new_data = pd.read_csv('new_data.csv')

# Preprocess the new dataset
preprocessed_new_data = preprocess_data(new_data)  # Assumes the same preprocessing is applied as before

# Predict
predicted_labels = trained_model.predict(preprocessed_new_data)