Exception has occurred: ValueError Data cardinality is ambiguous: x sizes: 1280 y sizes: 32 Make sure all arrays contain the same number of samples

Question

getting this error while training my GAN model for stock prediction with GRU as generator and CNN as discriminator, here's the code. I am getting value error at d_loss_fake data cardinality is ambiguous

import pandas as pd
import pandas_ta as ta
import numpy as np
import tensorflow as tf
from keras.models import Sequential
from keras.layers import GRU, Conv1D, MaxPooling1D, Flatten, Dense, concatenate, Reshape
from keras import Model, Input
from keras.optimizers import Adam
from sklearn.metrics import mean_absolute_error, mean_squared_error

# load training and testing data from CSV files and READ them into Dataframes
train_data_path = (r"C:\Users\lenovo\Projects\Stock_prediction_3.0\IBM_train.csv")
test_data_path = (r"C:\Users\lenovo\Projects\Stock_prediction_3.0\IBM_test.csv")
try:
  df_train = pd.read_csv(train_data_path, index_col="timestamp", parse_dates=True)
  df_test = pd.read_csv(test_data_path, index_col="timestamp", parse_dates=True)
except FileNotFoundError:
  print("Error: CSV files not found. Please check the paths.")
  exit()

# Function for technical analysis
def calculate_indicators(df, window_sizes=[20, 50, 14, 12, 26]):
 
    df['CCI'] = ta.cci(df['high'], df['low'], df['close'], window=window_sizes[0])
    # Calculate RSI
    df['RSI_close'] = ta.rsi(df['close'], window=window_sizes[2])
    df['RSI_volume'] = ta.rsi(df['volume'], window=window_sizes[2])

    # Calculate EMA
    df["EMA_close"] = ta.ema(df['close'], window=window_sizes[0])
    df["EMA_volume"] = ta.ema(df['volume'], window=window_sizes[0])

    # Calculate SMA
    df["SMA_close"] = ta.sma(df['close'], window=window_sizes[1])
    df["SMA_volume"] = ta.sma(df['volume'], window=window_sizes[1])

    # Calculate ATR
    df['ATR_close'] = ta.atr(df['high'], df['low'], df['close'], length=window_sizes[0])

    return df

window_sizes = [20, 50, 14, 12, 26]
df_train = calculate_indicators(df_train, window_sizes)
df_test = calculate_indicators(df_test, window_sizes)

# Select relevant features
features = ['close','high','volume','low','RSI_close','RSI_volume','CCI','EMA_close','EMA_volume','SMA_close','SMA_volume','ATR_close']

# Normalize 'close' values
def normalize(df):
    df = df.dropna()
    df['close'] = (df['close'] - df['close'].min()) / (df['close'].max() - df['close'].min())
    df = df.replace([np.inf, -np.inf], np.nan).dropna()
    return df

df_train = normalize(df_train)
df_test = normalize(df_test)

# Define GRU generator
generator_input = Input(shape=(len(features), 1))
generator_output = GRU(64, return_sequences=True)(generator_input)
generator_output = GRU(32, return_sequences=False)(generator_output)
generator_output = Dense(1)(generator_output)
generator = Model(inputs=generator_input, outputs=generator_output)

#Define GRU discriminator
discriminator_input = Input(shape=(len(features), 1))
# Pass directly to Conv1D without additional Reshape
x = Conv1D(filters=32, kernel_size=2, activation="relu", padding="same")(discriminator_input)
x = MaxPooling1D(pool_size=1)(x)  # Now compatible with 3D input
x = Conv1D(filters=64, kernel_size=2, activation="relu", padding="same")(x)
x = MaxPooling1D(pool_size=1)(x)  
x = Dense(32, activation="relu")(x)
discriminator_output = Dense(1, activation="sigmoid")(x)
discriminator = Model(inputs=discriminator_input, outputs=discriminator_output)

# Define GAN model
gan_input = Input(shape=(len(features), 1))
gan_output = discriminator(generator(gan_input))
gan = Model(inputs=gan_input, outputs=gan_output)

# Compile models
discriminator.compile(optimizer=Adam(learning_rate=0.001), loss="binary_crossentropy", metrics=["accuracy"])
gan.compile(optimizer=Adam(learning_rate=0.001), loss="binary_crossentropy")

# Train GAN model
def train_gan(gan, generator, discriminator, df_train_norm, epochs=100, batch_size=32, save_interval=10):
    x_train = df_train_norm[features].values.reshape(-1, len(features), 1)
    x_train = x_train.astype('float32')  # Convert to float32
    y_train = np.ones((df_train_norm.shape[0], 1), dtype='float32')
    x_train = tf.stack(x_train)
    y_train = tf.stack(y_train)

    for epoch in range(epochs):
        # Train discriminator
        d_loss_real = discriminator.train_on_batch(x_train, y_train)
        d_loss_fake = discriminator.train_on_batch(generator.predict(x_train), np.zeros((batch_size, 1)))
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

        # Train generator
        g_loss = gan.train_on_batch(x_train, y_train)

        # Print training progress
        if epoch % save_interval == 0:
            print(f"Epoch: {epoch+1}/{epochs}, Discriminator Loss: {d_loss:.4f}, Generator Loss: {g_loss:.4f}")

# Train the model
train_gan(gan, generator, discriminator, df_train)

I tried converting both train variables to tf.stack but still it shows value error at d_loss_fake while training the discriminator