GAN：Gradient Tape 计算判别器的零梯度

Question

I'm computing gradients for the discriminator using gradient tape. Discriminator model has custom layers and filters, but the gradients are zero. The gradients for the generator are being computed just fine. The model is processing the audios and the custom filters initialized as tf variables with trainable set as true

---

This is the discriminator

def discriminator(images_from_before, filters):
    #Discriminator
    #3x1 Convolution
    conv_3 = tf.nn.conv1d(input = images_from_before,
                filters = filters.filters[0][0],
                stride = 1,
                padding = 'SAME',
                data_format = 'NWC')
    #9x1 Convolution
    conv_9 = tf.nn.conv1d(input = images_from_before,
                filters = filters.filters[0][1],
                stride = 1,
                padding = 'SAME',
                data_format = 'NWC')
    #27x1 Convolution
    conv_27 = tf.nn.conv1d(input = images_from_before,
                filters = filters.filters[0][2], #some of the whole tfVariable
                stride = 1,
                padding = 'SAME',
                data_format = 'NWC')
    #81x1 Convolution
    conv_81 = tf.nn.conv1d(input = images_from_before,
                filters = filters.filters[0][3], #some of the whole tfVariable
                stride = 1,
                padding = 'SAME',
                data_format = 'NWC')
            
    out = tf.concat([conv_3,conv_9,conv_27,conv_81], 2)

    out = leaky_relu(out,0.2)

    #7x Discriminator block
    for i in range(7):
        out = discriminator_block(out,filters.filters[i+1],filters.BN_val[i])

    #Flatten width of the out tensor    
    mul_FC = out.shape[1] * out.shape[2]

    #FC - Dropout - LeakyReLU
    #Flatten out
    out = tf.reshape(out, shape = [out.shape[0],mul_FC])
    out = FClayer(out,filters.FC1, filters.bias1)
    out = Dropout(out)
    out = leaky_relu(out,0.2)

    #FC - Sigmoid
    out = FClayer(out, filters.FC2, filters.bias2)

    out = tf.math.sigmoid(out)

    #implicit mean over the minibatch samples
    out = tf.math.reduce_mean(out)

    out = tf.clip_by_value(out,0.1, 0.9)

    return out

The gradients are being calculated as follow

with tf.GradientTape() as gen_tape, tf.GradientTape() as dis_tape:
        gen_out = generator.generator(downsampled, num_of_blocks, gen_var)
        
        gen_dis = discriminator.discriminator(gen_out,dis_var)     
        
        #compute losses
        gen_loss = losses.generator_loss(
                            losses.L2_loss(upsampled, gen_out),
                            losses.Lf_loss(upsampled, gen_out,auto_var,4),
                            losses.Ladv_loss(gen_dis,dis_var), #updated
                            lamda_f,
                            lamda_adv)

        dis_loss = losses.discriminator_loss(0.1, 
                                             gen_dis)
        
    print('Gen loss: {}'.format(gen_loss.numpy()))
    print('Dis loss: {}'.format(dis_loss.numpy()))
    


    gen_grads = gen_tape.gradient(gen_loss, [gen_var.dfilters,
                                             gen_var.ufilters,
                                             gen_var.finalfilter,
                                             gen_var.prelu])
    
    disc_grads = dis_tape.gradient(dis_loss, [dis_var.filters,
                                              dis_var.BN_val,
                                              dis_var.FC1,
                                              dis_var.bias1,
                                              dis_var.FC2,
                                              dis_var.bias2])

Answer 1

The gradient tape needs to have the parameter persistent=True