PyTorch-Lightning can't train gan the Generator gradient is 0

[2651084156]

the Discriminator train is work
but when i train Generator is dosen't work
and i find is gradient is 0

i don't know the reason
and i look the examples this
https://pytorch-lightning.readthedocs.io/en/stable/notebooks/lightning_examples/basic-gan.html

but i didn't know what mistake in my code

this is my code

my code

import os import time from collections import OrderedDict from pl_bolts.models.gans import DCGAN import numpy import numpy as np import torch

import torch.nn as nn
import pytorch_lightning as pyl
from torch.autograd import Variable
from torch.autograd._functions import tensor
from torch.utils.data import Dataset, DataLoader
import matplotlib.pyplot as plt
import pandas as pd
import cv2
from PIL import Image
class jian(nn.Module):
def init(self, ):
super().init()
self.ganj = nn.Sequential(nn.Conv2d(in_channels=3, out_channels=300, kernel_size=(8, 8), stride=(2, 2)),
nn.BatchNorm2d(300), nn.LeakyReLU(0.2),
nn.Conv2d(in_channels=300, out_channels=300, kernel_size=(8, 8), stride=(2, 2)),
nn.BatchNorm2d(300), nn.LeakyReLU(0.2),
nn.Conv2d(in_channels=300, out_channels=3, kernel_size=(8, 8), stride=(2, 2)),
nn.LeakyReLU(0.2)) # 22 17

    self.ganj2 = nn.Sequential(nn.Linear(3 * 22 * 17, 1), nn.Sigmoid())

def forward(self, x):
    a = self.ganj(x)
    b = self.ganj2(a.view(3 * 22 * 17))
    # b = self.ganj2(a.view(3*22*17*4))
    return b

class grent(nn.Module):
def init(self,):
super().init()
self.ganout1 = nn.Sequential(nn.Linear(100, 6 * 22 * 17), nn.SELU())
# self.ganout1 = nn.Sequential(nn.Linear(1, 3 * 22 * 17), nn.LeakyReLU(0.2),nn.Linear(3 * 22 * 17, 3 * 50 * 30), nn.LeakyReLU(0.2),nn.Linear( 3 * 50 * 30, 3 * 150 * 50), nn.LeakyReLU(0.2),nn.Linear( 3 * 150 * 100, 3 * 200 * 150), nn.SELU(),nn.Linear( 3 * 200 * 150, 3 * 218 * 178), nn.Sigmoid())
# self.ganout1 = nn.Sequential(nn.Linear(10, 3 * 218 ), nn.LeakyReLU(0.2),nn.Linear(3 * 218, 3000 ), nn.LeakyReLU(0.2),nn.Linear(3000 , 3 * 218 * 178),nn.Sigmoid())

    self.ganout = nn.Sequential(
        nn.ConvTranspose2d(in_channels=6, out_channels=400, kernel_size=(8, 8), stride=(2, 2)), nn.BatchNorm2d(400),
        nn.SELU(), nn.ConvTranspose2d(in_channels=400, out_channels=400, kernel_size=(8, 8), stride=(2, 2)),
        nn.BatchNorm2d(400), nn.SELU(),
        nn.ConvTranspose2d(in_channels=400, out_channels=3, kernel_size=(8, 8), stride=(2, 2)),
        nn.Sigmoid())
def forward(self, x):
    a = self.ganout1(x)

    # a =a.view((1,3 , 218, 178))
    b = self.ganout(a.view((1,6 , 22, 17)))
    # b = self.ganj2(a.view(3*22*17*4))
    return b

class main_modle(pyl.LightningModule):
def init(self, ):
super().init()

    self.ganout = grent()

    self.ganj = jian()




def forward(self, inputs):
    a =self.ganout(inputs)

    # b = self.ganj2(a.view(3*22*17*4))
    return a


def configure_optimizers(self):
    optimizer = torch.optim.Adam(self.ganj.parameters(),lr=0.00001)
    # optimizer2 = torch.optim.Adam(self.ganout.parameters(),lr=0.0003 )
    optimizer2 = torch.optim.Adam(self.parameters(), lr=0.0003)
    return optimizer2,optimizer

    # return optimizer,

def training_step(self, batch, batch_idx,optimizer_idx):
# def training_step(self, batch, batch_idx,):
#     x , y =batch
    self.loss_function = nn.BCELoss()



    x = batch[0]
    if optimizer_idx == 1:
        if batch_idx%1==0:
            outt=self.ganj(x)
            if torch.isnan(outt).any():
                outt =Variable(torch.tensor([1.0]),requires_grad=True).type_as(x)
            aa = torch.as_tensor(torch.Tensor([1.0])).type_as(x)
            realloss =self.loss_function(outt,aa)
            aaas = torch.round(self.forward(torch.randn([100]).type_as(x) ) *255)
            outt2 = self.ganj(aaas.detach())
            if torch.isnan(outt2).any():
                outt2 =Variable(torch.tensor([0.0]),requires_grad=True).type_as(x)
            aa2 = torch.as_tensor(torch.Tensor([0.0])).type_as(x)
            fuckloss = self.loss_function(outt2, aa2)

            mainloss = (realloss +fuckloss) /2
            csdfsd =0
            tqdm_dict = {"d_loss": mainloss}
            output = OrderedDict({"loss": mainloss, "progress_bar": tqdm_dict, "log": tqdm_dict})
            return output
        # else:
        #
        #     mainloss = fuckloss
        #     tqdm_dict = {"d_loss": mainloss}
        #     csdfsd = 0
        #     output = OrderedDict({"loss": mainloss, "progress_bar": tqdm_dict, "log": tqdm_dict})
        #     return output
    if optimizer_idx == 0:
        self.loss_function2 = nn.MSELoss()
        aaas =torch.round(self.ganout(torch.randn([100]).type_as(x))*255)
        outt2 = self.ganj(aaas)
        if torch.isnan(outt2).any():
            outt2 =Variable(torch.tensor([0.0]),requires_grad=True).type_as(x)

        asds =torch.Tensor([1.0]).type_as(x)
        losss = self.loss_function2(outt2,asds)
        csdfsd = 0

        if batch_idx%100 ==0:
            print(self.ganout.state_dict().keys())
            print(self.ganout.ganout1[0].weight)
            print(self.ganout.ganout1[0].weight.grad)
            img_1 = aaas[0].cpu().detach().numpy()
            img_1 = img_1.astype('uint8')
            img_1 = np.transpose(img_1, (1, 2, 0))  # 将通道数移到最后
            cv2.imwrite('./114/'+str(batch_idx)+'.png',img_1)

        # losss.backward()
        tqdm_dict = {"g_loss": losss}
        output = OrderedDict({"loss": losss, "progress_bar": tqdm_dict, "log": tqdm_dict})
        return output
        #
        # return losss








    # a =x.shape
    # c =self.forward(x)
    # # print(c.shape)
    # # print (a)
    aaaaasss =0


    # return self.loss_function(c,aa)
def test_step(self, batch, batch_idx):
    pass

class dataset2(Dataset):
def init(self, csc_file):
# self.data_df= pd.read_csv(csc_file,header=None)
self.filll = os.listdir(csc_file)
# print( self.filll)
self.num =len(self.filll)
if csc_file[-1] == '/':
self.path = csc_file
else:
self.path = csc_file + '/'

def __len__(self):
    return self.num
    # return self.num + 212000

def __getitem__(self, index):

    if index <= self.num:
    # if 0:
        filllsd = self.filll[index]

        img = cv2.imread(self.path + filllsd)
        image1 = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        imgg = torch.FloatTensor(img)
        img = numpy.transpose(imgg, (2, 0, 1))
        # input = torch.from_numpy(img)
        input1 = torch.FloatTensor(img)
        ttttfff = torch.Tensor([1])
        # print(0000000000000000)
        # print(input1.shape)
        # imgg =imgg.resize((1,3,218,178))

        # image = Variable(torch.unsqueeze(image, dim=0).float(), requires_grad=False)
        # imggf = Variable(torch.unsqueeze(th.FloatTensor(r), dim=0).float(), requires_grad=False)
        # cv2.imshow("windows_name", np.uint8(imggf.cpu().numpy()))
        # cv2.waitKey()
        # print(imggf)
        # image = image
        # return label ,image ,target
        # print(img.shape)
        # tesyt = np.uint8(imggf.cpu().numpy())
    else:
        acc = torch.rand([ 3, 218, 178]) * 255
        acc = torch.round(acc)
        input1 = acc
        ttttfff = torch.Tensor([0])
        # print(1111111111111111)

    # return input1,ttttfff
    return input1,
    # return  image, target

aaa =dataset2(r'K:\aaaaa\Img\img_align_celeba')
from pytorch_lightning.loggers import TensorBoardLogger
logger = TensorBoardLogger('tb_logs', name='my_model')
trainer = pyl.Trainer(gpus=1,logger =logger)

trainer.fit(model=main_modle(),train_dataloader=DataLoader(aaa,shuffle=True,batch_size=1))

[2651084156]

dose anyone can help me?