keras shows nan output and loss even when normalized

i wrote this short script for training on stock data. the idea is to give out -1 for sell and 1 for buy. the only problem is that the output is nan

i tried normalizing the output but it did not do anything. also the model only returns nan after first step. before the first step the output is fine

from matplotlib import pyplot as plt
import keras
import tensorflow as tf
import pandas as pd
import math
import gc
import numpy as np


chunksize = 80

start = pd.to_datetime(['2022-5-01']).astype(int)[0]//10**9 # convert to unix timestamp.
end = pd.to_datetime(['2022-12-31']).astype(int)[0]//10**9 # convert to unix timestamp.
url = 'https://query1.finance.yahoo.com/v7/finance/download/' + 'AAPL' + '?period1=' + str(start) + '&period2=' + str(end) + '&interval=1d&events=history'
gld = pd.read_csv(url)
gld['return'] = np.log(gld['Close']).diff()

def splice_arr(arr, size):
    
    i = 0
    out = []
    while i < len(arr) - size:
        out.append(arr[i:i + size])
        i += 1
    return out

data = splice_arr(gld['return'].to_numpy(), chunksize)
x = tf.data.Dataset.from_tensor_slices(data)


def Generator():
    model_m = keras.models.Sequential()
    
    model_m.add(keras.layers.Conv1D(100, 10, activation='relu', input_shape=(chunksize, 1)))
    model_m.add(keras.layers.Conv1D(100, 10, activation='relu'))
    model_m.add(keras.layers.MaxPooling1D(3))
    model_m.add(keras.layers.Conv1D(160, 10, activation='relu'))
    model_m.add(keras.layers.Conv1D(160, 10, activation='relu'))
    model_m.add(keras.layers.GlobalAveragePooling1D())
    model_m.add(keras.layers.Dropout(0.5))
    model_m.add(keras.layers.Dense(2, activation='softmax'))
    model_m.add(keras.layers.Dense(1, activation='sigmoid'))
    model_m.add(tf.keras.layers.Normalization(axis=1))
    return model_m

model = Generator()

print(model(data[0].reshape(1, chunksize, 1)).numpy())


def generator_loss(genor_output1):
    dat = tf.constant(gld["return"][chunksize + 1:].values.reshape(len(gld['return']) - (chunksize + 1), 1), dtype=tf.float32)
    print(dat)
    print(genor_output1)
    dat = tf.math.multiply(genor_output1, dat)
    
    
    # dat = np.where(gen_output1 < 0.5, 0, dat)
    # dat = np.where((gen_output1.diff()) > 0, dat - dat * 0.04, dat)
    # dat = dat.cumprod() * -1
    dat = tf.math.exp(dat)
    dat2 = tf.reduce_sum(dat)
    dat2 = tf.math.divide(1, dat2)
    return dat2, dat

generator_optimizer = tf.keras.optimizers.Adam(learning_rate=0.001, epsilon=2e-4, beta_1=0.5)
loss_object = tf.keras.losses.BinaryCrossentropy(from_logits=True)

@tf.function
def train_step():  
  with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
    tf.compat.v1.enable_eager_execution()
    gen_output = []
    gen_output.append(model(data[0].reshape(1, chunksize, 1), training=True))
    indexed = 1
    
    for i in range(len(data) - 2):
        gen_output.append(model(data[indexed].reshape(1, chunksize, 1), training=True))
        indexed += 1
        
        
    gen_output = tf.concat(gen_output, axis=0)
    gen_total_loss, curve = generator_loss(gen_output)
  
  generator_gradients = gen_tape.gradient(gen_total_loss,
                                          model.trainable_variables)
  
  generator_optimizer.apply_gradients(zip(generator_gradients,
                                          model.trainable_variables))
  gc.collect()
  return curve
    

    



def fit(steps):
  
  step = 0
  while step < steps:
    for i in range(steps):
    
      if step % 1 == 0:
        
    
        plt.plot(train_step().numpy().reshape(len(gld['return']) - (chunksize + 1)).cumprod())
        plt.plot(np.exp(gld["return"][chunksize + 1:].values.reshape(len(gld['return']) - (chunksize + 1))).cumprod())
        plt.show()
        print(f"Step: {step}")
      gc.collect()
      train_step()

      # Training step
      step += 1
      print('.', end='', flush=True)



fit(10)

please help