Training with TimeseriesGenerator doesn't start immediatly - tensorflow

Question

I want to train my timeseries prediction model (LSTM-model, using tensorflow 2.2) with using the timeseries generator in order to generate the data on the fly.
What I observed is that the train loss decreases good in the first steps of training, but then it increases with the last 12 steps. Then I found out, that the model.fit method runs the timeseriesgenerator 11 times and starts training after that. So thats the cause that my model doesn't train with the first samples of data and therefore starts in the middle of my dataset. When I reach the end of the epochs, there is no data left so it gets an empty array and I think that this "destoys" the training progress and therefore the training loss starts to increase.
Here are the important parts of my code to understand my problem:
Model:
model = keras.Sequential()
model.add(keras.layers.Bidirectional(k.layers.LSTM(20, activation='relu'), input_shape=(seq_length, 1)))
model.add(keras.layers.Dense(1))
Training:
training_data = DataGenerator(data=train_data,
seq_length=1024,
batch_size=2048,
shuffle=False)
training_process = model.fit(x=training_data,
epochs=8,
verbose=True,
validation_data=validation_data)
The DataGenerator class countains the data generator, with the real values after the # :
class DataGenerator(k.utils.Sequence):
def __init__(self, data, seq_length, batch_size, shuffle=True):
self.data = data
self.n_sequences = np.shape(self.data)[0] #2
self.data_length = np.shape(self.data)[1] #60000
self.seq_length = seq_length #1024
self.batch_size = batch_size #2048
self.shuffle = shuffle #False
self.seq_index = 0
self.own_index = 0
self.n_batches = int(np.floor((self.data_length-self.seq_length)/self.batch_size)) #28
self.on_epoch_end()
def __len__(self):
return int(np.floor((self.data_length-self.seq_length)/self.batch_size)*self.n_sequences) #56
def __getitem__(self, index):
print('own index=' + str(self.own_index)) # for testing generator
index = int(self.own_index/self.n_batches) #0
start = (self.own_index % self.n_batches) * self.batch_size #0
end = start + self.batch_size #2048
gen = TimeseriesGenerator(data=self.data[index],
targets=self.data[index],
length=self.seq_length,
sampling_rate=1, stride=1, start_index=start, end_index=end,
shuffle=False, reverse=False, batch_size=self.batch_size)
self.own_index += 1
if self.own_index > (self.n_sequences*self.n_batches-1):
self.own_index = 0
x, y = gen[0]
x = np.expand_dims(x, axis=2)
return x, y
def on_epoch_end(self):
self.own_index = 0
if self.shuffle is True:
perm = np.random.permutation(self.data.shape[0])
self.data = self.data[perm]
When I run this code, I get the following output:
own index=0 own index=1 own index=2 own index=3 own index=4 own
index=5 own index=6 own index=7 own index=8 own index=9 own index=10
own index=11
1/56 [..............................] - ETA: 0s - loss: 0.3705own
index=12
So the training starts with the index of 12, which causes the start-value to be 24576 instead of 0. So all the data before this start index are not used for training.
Can someone help me to find out, what causes the fit method to run the generator 11 times before training starts?