i have following code:
# %%
import pandas as pd
import numpy as np
from tensorflow import keras
from sklearn.preprocessing import StandardScaler

def data_generator(file_path, batch_size, data_type):
    chunksize = batch_size
    total_rows = 301617  # Adjust with your dataset's actual number of rows
    split_ratio = 0.92  # Assuming 80% for train, 20% for validation
    train_rows = int(total_rows * split_ratio)
    while True:  # Loop forever, so the generator never terminates
        for chunk in pd.read_csv(file_path, chunksize=chunksize):

            if data_type == 'train' and row_counter >= train_rows:
                continue  # Skip the rest if we are fetching training data but have reached the end of the train set
            elif data_type == 'val' and row_counter < train_rows:
                row_counter += len(chunk)
                continue  # Skip this chunk if we are fetching validation data but are still in the train range
            # Assuming your CSV has headers that match features/targets
            # Normalizing the features
            filtered_c = chunk.drop(['Date', 'Symbol'], axis=1)
            
            feature_data = filtered_c.drop([
                '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)
            target_data = filtered_c[['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'
                   ]]
            scaler = StandardScaler()
            feature_data_scaled = pd.DataFrame(scaler.fit_transform(feature_data), columns=feature_data.columns)
            # Assuming target_data also needs to be scaled, apply scaler separately
            target_data_scaled = pd.DataFrame(scaler.fit_transform(target_data), columns=target_data.columns)

            # Now, feature_data_scaled and target_data_scaled are both DataFrames, scaled and ready to use
            yield feature_data_scaled.values, target_data_scaled.values
            row_counter += len(chunk)


# %%

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Input
import tensorflow as tf

def build_model():
    input_shape = (6427,)
    
    model = Sequential([
    Dense(6427, activation='relu', input_shape = input_shape),
    Dropout(0.25),
    Dense(3200, activation='relu'),
    Dropout(0.20),
    Dense(1800, activation='relu'),
    Dropout(0.15),
    Dense(1024, activation='relu'),
    Dropout(0.10),
    Dense(512, activation='relu'),
    Dropout(0.05),
    Dense(256, activation='relu'),
    Dense(128, activation='relu'),
    Dense(64, activation='relu'),
    Dense(32, activation='relu'),
    Dense(12),
    ])
    
    model.compile(optimizer='adam',
                  loss='mse',  # Use Mean Squared Error for regression
                  metrics=['mae'])  # Mean Absolute Error as an additional metric
    return model


# %%
file_path = r"C:\Users\arisa\Desktop\combined_day.csv"
batch_size = 128

# Instantiate the model
model = build_model()

model.summary()

# %%
train_generator = data_generator(file_path, batch_size, 'train')
val_generator = data_generator(file_path, batch_size, 'val')

total_samples = 301617  # Assuming same example size
train_samples = int(total_samples * 0.92)
val_samples = total_samples - train_samples

steps_per_epoch = train_samples // batch_size
validation_steps = val_samples // batch_size

# Modify the model fitting call to include validation data
model.fit(
    train_generator, 
    steps_per_epoch=steps_per_epoch, 
    epochs=100,
    validation_data=val_generator, 
    validation_steps=validation_steps
)


# %%
# Setup the data generator
train_generator = data_generator(file_path,batch_size)

# Assuming you know or calculate the total number of rows in advance
total_samples = 301617  # Example number, replace with your dataset's size
steps_per_epoch = total_samples // batch_size

# Train the model
model.fit(train_generator, steps_per_epoch=1000, epochs=10)

# %%
import tensorflow as tf

if tf.test.gpu_device_name(): 
    print('Default GPU Device: {}'.format(tf.test.gpu_device_name()))
else:
    print('Please install GPU version of TF')





is there a way that i can use a general StandardScaler for my dataset instead of creating new StandardScaler for each chunk?which approach is suggested