i have historical data of crypto as csv files,
i have following code to train a model on them whithout merging them,:

import os
import numpy as np
import pandas as pd
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

def data_generator(file_paths, batch_size, train=True, scaler=None):
while True: # Loop forever so the generator never terminates
# Shuffle file paths to ensure random distribution of data across files
np.random.shuffle(file_paths)

for file_path in file_paths:
data = pd.read_csv(file_path)

# Split features and labels
X = data.drop([
‘Date’, ‘Symbol’,
‘y_High_1d’, ‘y_Low_1d’, ‘y_Priority_1d’,
‘y_High_2d’, ‘y_Low_2d’, ‘y_Priority_2d’,
‘y_High_3d’, ‘y_Low_3d’, ‘y_Priority_3d’,
‘y_High_5d’, ‘y_Low_5d’, ‘y_Priority_5d’], axis=1).values

y_high_1d = data[‘y_High_1d’].values
y_low_1d = data[‘y_Low_1d’].values
y_Priority_1d = data[‘y_Priority_1d’].values

y_high_2d = data[‘y_High_2d’].values
y_low_2d = data[‘y_Low_2d’].values
y_Priority_2d = data[‘y_Priority_2d’].values

y_high_3d = data[‘y_High_3d’].values
y_low_3d = data[‘y_Low_3d’].values
y_Priority_3d = data[‘y_Priority_3d’].values

y_high_5d = data[‘y_High_5d’].values
y_low_5d = data[‘y_Low_5d’].values
y_Priority_5d = data[‘y_Priority_5d’].values

# Optionally, apply preprocessing here (e.g., Scaler transform)
if scaler is not None and train:
X = scaler.fit_transform(X)
elif scaler is not None:
X = scaler.transform(X)

# Splitting data into batches
for i in range(0, len(data), batch_size):
end = i + batch_size
X_batch = X[i:end]

y_high_batch_1d = y_high_1d[i:end]
y_low_batch_1d = y_low_1d[i:end]
y_priority_batch_1d = y_priority_1d[i:end]

y_high_batch_2d = y_high_2d[i:end]
y_low_batch_2d = y_low_2d[i:end]
y_priority_batch_2d = y_priority_2d[i:end]

y_high_batch_3d = y_high_3d[i:end]
y_low_batch_3d = y_low_3d[i:end]
y_priority_batch_3d = y_priority_3d[i:end]

y_high_batch_5d = y_high_5d[i:end]
y_low_batch_5d = y_low_5d[i:end]
y_priority_batch_5d = y_priority_5d[i:end]

yield X_batch, [y_high_batch_1d, y_low_batch_1d,y_priority_batch_1d,
y_high_batch_2d, y_low_batch_2d,y_priority_batch_2d,
y_high_batch_3d, y_low_batch_3d, y_priority_batch_3d,
y_high_batch_5d, y_low_batch_5d, y_priority_batch_5d]


dataset_dir = r’F:\day_spot’
file_paths = [os.path.join(dataset_dir, file_name) for file_name in os.listdir(dataset_dir)]
train_files, val_files = train_test_split(file_paths, test_size=0.06, random_state=42)

batch_size = 72

# Optional: Initialize a scaler for data normalization
scaler = StandardScaler()

# Create data generators
train_gen = data_generator(train_files, batch_size, train=True, scaler=scaler)
val_gen = data_generator(val_files, batch_size, train=False, scaler=scaler)

input_shape = (6427,)

inputs = Input(shape=(input_shape,))


x = Dense(6427, activation=‘relu’, input_shape=(input_shape,)) (inputs)
x = Dropout(0.35) (x)
x = Dense(3200, activation=‘relu’) (x)
x = Dropout(0.30) (x)
x = Dense(1800, activation=‘relu’) (x)
x = Dropout(0.25) (x)
x = Dense(1024, activation=‘relu’) (x)
x = Dropout(0.20) (x)
x = Dense(512, activation=‘relu’) (x)
x = Dropout(0.15) (x)
x = Dense(256, activation=‘relu’) (x)
x = Dropout(0.1) (x)
x = Dense(128, activation=‘relu’) (x)
x = Dropout(0.05) (x)
x = Dense(64, activation=‘relu’) (x)
x = Dropout(0.05) (x)
x = Dense(32, activation=‘relu’) (x)



# Defining three separate outputs

out_high_1d = Dense(1, name=‘high_output_1d’)(x) # No activation, linear output
out_low_1d = Dense(1, name=‘low_output_1d’)(x) # No activation, linear output
out_priority_1d = Dense(1, activation=‘sigmoid’, name=‘priority_output_1d’)(x)

out_high_2d = Dense(1, name=‘high_output_2d’)(x) # No activation, linear output
out_low_2d = Dense(1, name=‘low_output_2d’)(x) # No activation, linear output
out_priority_2d = Dense(1, activation=‘sigmoid’, name=‘priority_output_2d’)(x)

out_high_3d = Dense(1, name=‘high_output_3d’)(x) # No activation, linear output
out_low_3d = Dense(1, name=‘low_output_3d’)(x) # No activation, linear output
out_priority_3d = Dense(1, activation=‘sigmoid’, name=‘priority_output_3d’)(x)

out_high_5d = Dense(1, name=‘high_output_5d’)(x) # No activation, linear output
out_low_5d = Dense(1, name=‘low_output_5d’)(x) # No activation, linear output
out_priority_5d = Dense(1, activation=‘sigmoid’, name=‘priority_output_5d’)(x)

# Constructing the model
model = Model(inputs=inputs, outputs=[
out_high_1d, out_low_1d, out_priority_1d,out_high_2d, out_low_2d, out_priority_2d,
out_high_3d, out_low_3d, out_priority_3d,out_high_5d, out_low_5d, out_priority_5d])

model.compile(optimizer=‘adam’,
loss={
‘out_high_1d’: ‘mse’, ‘out_low_1d’: ‘mse’, ‘out_priority_1d’: ‘binary_crossentropy’,
‘out_high_2d’: ‘mse’, ‘out_low_2d’: ‘mse’, ‘out_priority_2d’: ‘binary_crossentropy’,
‘out_high_3d’: ‘mse’, ‘out_low_3d’: ‘mse’, ‘out_priority_3d’: ‘binary_crossentropy’,
‘out_high_5d’: ‘mse’, ‘out_low_5d’: ‘mse’, ‘out_priority_5d’: ‘binary_crossentropy’
},
metrics={
‘out_high_1d’: [‘mae’], ‘out_low_1d’: [‘mae’], ‘out_priority_1d’: [‘accuracy’],
‘out_high_2d’: [‘mae’], ‘out_low_2d’: [‘mae’], ‘out_priority_2d’: [‘accuracy’],
‘out_high_3d’: [‘mae’], ‘out_low_3d’: [‘mae’], ‘out_priority_3d’: [‘accuracy’],
‘out_high_5d’: [‘mae’], ‘out_low_5d’: [‘mae’], ‘out_priority_5d’: [‘accuracy’]
}
loss_weights={
‘out_high_1d’: 1.0, ‘out_low_1d’: 1.0, ‘out_priority_1d’: 1.0,
‘out_high_2d’: 1.0, ‘out_low_2d’: 1.0, ‘out_priority_2d’: 1.0,
‘out_high_3d’: 1.0, ‘out_low_3d’: 1.0, ‘out_priority_3d’: 1.0,
‘out_high_5d’: 1.0, ‘out_low_5d’: 1.0, ‘out_priority_5d’: 1.0
}
)



def count_samples(file_paths):
total_samples = 0
for file_path in file_paths:
df = pd.read_csv(file_path)
samples = len(df)
total_samples += samples
return total_samples

number_of_training_samples = count_samples(train_files)
number_of_validation_samples = count_samples(val_files)

print(f’Number of training samples: {number_of_training_samples}‘)
print(f’Number of validation samples: {number_of_validation_samples}’)



# You’ll need to determine steps_per_epoch and validation_steps based on your data size and batch size
steps_per_epoch = np.ceil(number_of_training_samples / batch_size) # Replace number_of_training_samples
validation_steps = np.ceil(number_of_validation_samples / batch_size) # Replace number_of_validation_samples

model.fit(train_gen,
steps_per_epoch=steps_per_epoch,
validation_data=val_gen,
validation_steps=validation_steps,
epochs=10000)


in this code i train a standard neural network on my data
please update code so i train LSTM model instead of standard neural network