How loss backpropagated to provide the effective weights for next iteration of batch?

I tried to fuse the multiple losses but that are not effecting the weights for next iteration, I would like to fuse the loss function because I am getting multiple output from the generating model. How may I solve it?

def train(self, epochs, batch_size=1, sample_interval=50):
    LAMBDA = 0.1
    start_time = datetime.datetime.now()
    for epoch in range(epochs):
        if epoch % 500 == 0:
            optimizer = Adam(0.0001, 0.5)
        self.combined.compile(loss=['mae'], loss_weights=[1, 100], optimizer=optimizer)
        for batch_i, (imgs_A, imgs_B) in enumerate(self.data_loader.load_batch(batch_size)):
            # os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
            fake_A1, fake_A2, fake_A3 = self.generator.predict(imgs_B)

            g1_loss = self.combined.train_on_batch([imgs_A, imgs_B], [fake_A1])
            fake_A2 = tf.image.resize(fake_A2, [256, 256])
            fake_A3 = tf.image.resize(fake_A3, [256, 256])
            g2_loss = self.combined.train_on_batch([imgs_A, imgs_B], [fake_A2])
            g3_loss = self.combined.train_on_batch([imgs_A, imgs_B], [fake_A3])

            g1_loss = tf.cast(g1_loss, tf.double)
            g2_loss = tf.cast(g2_loss, tf.double)
            g3_loss = tf.cast(g3_loss, tf.double)
            g_loss = g1_loss + g2_loss + g3_loss

            imgs_A  = np.fft.fft2(imgs_A)
            fake_A1 = np.fft.fft2(fake_A1)
            fake_A2 = np.fft.fft2(fake_A2)
            fake_A3 = np.fft.fft2(fake_A3)

            mse = tf.keras.losses.MeanSquaredError()
            l1_loss = mse(imgs_A, fake_A1).numpy()
            l2_loss = mse(imgs_A, fake_A2).numpy()
            l3_loss = mse(imgs_A, fake_A3).numpy()
            l1_loss = tf.cast(l1_loss, tf.double)
            l2_loss = tf.cast(l2_loss, tf.double)
            l3_loss = tf.cast(l3_loss, tf.double)
            l_loss = l1_loss + l2_loss + l3_loss
            #Normalized loss
            g_loss = g_loss + (LAMBDA * l_loss)
            elapsed_time = datetime.datetime.now() - start_time
            print("[Epoch %d/%d] [Batch %d/%d] [G loss: %f] time: %s" % (epoch, epochs, batch_i, self.data_loader.n_batches, g_loss, elapsed_time))

How do we backword the loss after normalization which is stored into g_loss using following formula: g_loss = g_loss + (LAMBDA * l_loss)

Such as the loss has been backpropagated in pytorch code present in the following link: https://github.com/chosj95/MIMO-UNet/blob/main/train.py

which is backpropagated using following statements in pytorch:

loss.backward()
optimizer.step()