{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"gpu","dataSources":[{"sourceId":21755,"databundleVersionId":1475600,"sourceType":"competition"}],"dockerImageVersionId":30698,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        pass\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import torch\nfrom torch import nn\nfrom torch import optim\nimport PIL\nfrom PIL import Image\nimport io\nimport matplotlib.pyplot as plt\nimport torchvision\nimport gc","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"读取数据","metadata":{}},{"cell_type":"code","source":"monet_list=[]\nphoto_list=[]\nmonet_path='/kaggle/input/gan-getting-started/monet_jpg'\nphoto_path='/kaggle/input/gan-getting-started/photo_jpg'\nfor filename in os.listdir(monet_path):\n    file_path = os.path.join(monet_path, filename)\n    if os.path.isfile(file_path):\n        monet_list.append(np.array(Image.open(file_path)))\nfor filename in os.listdir(photo_path):\n    file_path = os.path.join(photo_path, filename)\n    if os.path.isfile(file_path):\n        photo_list.append(np.array(Image.open(file_path)))\nclass Datas(torch.utils.data.Dataset):\n    def __init__(self,monet_data,photo_data):\n        self.monet_data=monet_data\n        self.photo_data=photo_data\n    def __len__(self):\n        return len(self.monet_data)\n    def __getitem__(self,index):\n        r_num=np.random.randint(0,len(self.photo_data)-1)\n        return torch.tensor(self.monet_data[index],dtype=torch.float32),torch.tensor(self.photo_data[r_num],dtype=torch.float32)\ndatas=Datas(monet_list,photo_list)\n'''for m,p in loader:\n    for i,j in zip(m,p):\n        plt.subplot(1, 2, 1)\n        plt.imshow(torchvision.transforms.ToPILImage()(i.permute(2, 0, 1).byte()), cmap='gray')\n        plt.title('Image 1')\n        plt.subplot(1, 2, 2)\n        plt.imshow(torchvision.transforms.ToPILImage()(j.permute(2, 0, 1).byte()), cmap='gray')\n        plt.title('Image 2')\n        plt.show()'''","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"模型","metadata":{}},{"cell_type":"code","source":"class resnetblock(nn.Module):\n    def __init__(self,input_channel,output_channel):\n        super(resnetblock, self).__init__()\n        self.con1=nn.Conv2d(input_channel,output_channel,kernel_size=3,padding=1)\n        self.bn=nn.BatchNorm2d(output_channel)\n        self.relu=nn.ReLU()\n        self.con2=nn.Conv2d(output_channel,output_channel,kernel_size=3,padding=1)\n        self.con3=nn.Conv2d(input_channel,output_channel,kernel_size=1)\n    def forward(self,x):\n        Y=self.relu(self.bn(self.con1(x)))\n        Y=self.bn(self.con2(Y))\n        return self.relu(Y+self.con3(x))\nclass gen_resnet(nn.Module):\n    def __init__(self,down_channel,up_channel,middle_channel,channel,batch_size):\n        super(gen_resnet, self).__init__()\n        self.batch_size=batch_size\n        down_layer=[]\n        up_layer=[]\n        middle_layer=[]\n        module=[]\n        for input_channel,output_channel in down_channel:\n            down_layer+=[nn.ReflectionPad2d(2),nn.Conv2d(input_channel,output_channel,kernel_size=6,stride=2),nn.BatchNorm2d(output_channel),nn.ReLU()]\n        for input_channel,output_channel in middle_channel:\n            middle_layer.append(resnetblock(input_channel,output_channel))\n        for input_channel,output_channel in up_channel:\n            up_layer+=[nn.ConvTranspose2d(input_channel,output_channel,kernel_size=2,stride=2),nn.BatchNorm2d(output_channel),nn.ReLU()]\n        module=down_layer+middle_layer+up_layer+[nn.Conv2d(channel,channel,kernel_size=3,padding=1)]\n        self.gen=nn.Sequential(*module)\n    def forward(self,x):\n        return self.gen(x.permute(0,3,1,2))\nclass dis_resnet(nn.Module):\n    def __init__(self,down_channel,middle_channel,channel,batch_size):\n        super(dis_resnet, self).__init__()\n        self.batch_size=batch_size\n        down_layer=[]\n        middle_layer=[]\n        module=[]\n        for input_channel,output_channel in down_channel:\n            down_layer+=[nn.ReflectionPad2d(2),nn.Conv2d(input_channel,output_channel,kernel_size=6,stride=2),nn.BatchNorm2d(output_channel),nn.ReLU()]\n        for input_channel,output_channel in middle_channel:\n            middle_layer.append(resnetblock(input_channel,output_channel))\n        p1=[nn.MaxPool2d(kernel_size=3,padding=1,stride=1)]\n        module=down_layer+p1+middle_layer\n        self.dis=nn.Sequential(*module)\n        self.p=nn.AvgPool2d(kernel_size=3,padding=1,stride=1)\n        self.l=nn.Linear(channel,1)\n    def forward(self,x):\n        return self.l(self.p(self.dis(x.permute(0,3,1,2))).reshape(self.batch_size,-1))\nclass CycleGAN(nn.Module):\n    def __init__(self,down_channel,up_channel,middle_channel_g,middle_channel_d,channel_g,channel_d,batch_size):\n        super(CycleGAN, self).__init__()\n        self.g_m_t_p=gen_resnet(down_channel,up_channel,middle_channel_g,channel_g,batch_size)\n        self.g_p_t_m=gen_resnet(down_channel,up_channel,middle_channel_g,channel_g,batch_size)\n        self.d_m_t_p=dis_resnet(down_channel,middle_channel_d,channel_d,batch_size)\n        self.d_p_t_m=dis_resnet(down_channel,middle_channel_d,channel_d,batch_size)\n        self.g_confront_loss=nn.BCELoss()\n        self.g_cycle_loss=nn.L1Loss()\n        self.opt_gmtp=optim.Adam(self.g_m_t_p.parameters(),lr=5e-5,betas=(0.5, 0.999))\n        self.opt_gptm=optim.Adam(self.g_p_t_m.parameters(),lr=5e-5,betas=(0.5, 0.999))\n        self.opt_dmtp=optim.Adam(self.d_m_t_p.parameters(),lr=7e-5,betas=(0.5, 0.999))\n        self.opt_dptm=optim.Adam(self.d_p_t_m.parameters(),lr=7e-5,betas=(0.5, 0.999))\n    def forward(self,monet,photo):\n        f_p=self.g_m_t_p(monet)\n        f_m=self.g_p_t_m(photo)\n        reb_p=self.g_m_t_p(f_m.permute(0,2,3,1))\n        reb_m=self.g_p_t_m(f_p.permute(0,2,3,1))\n        m_t_p_r=self.d_m_t_p(photo)\n        p_t_m_r=self.d_p_t_m(monet)\n        m_t_p_f_d=self.d_m_t_p(f_p.permute(0,2,3,1).detach())\n        p_t_m_f_d=self.d_p_t_m(f_m.permute(0,2,3,1).detach())\n        m_t_p_f_g=self.d_m_t_p(f_p.permute(0,2,3,1))\n        p_t_m_f_g=self.d_p_t_m(f_m.permute(0,2,3,1))\n        return f_p,f_m,reb_p,reb_m,m_t_p_r,p_t_m_r,m_t_p_f_d,p_t_m_f_d,m_t_p_f_g,p_t_m_f_g\ndef init_weights(m):\n    if type(m) == nn.Linear or type(m) == nn.Conv2d:\n        nn.init.xavier_uniform_(m.weight)\n    elif type(m) == nn.ConvTranspose2d:\n        nn.init.xavier_uniform_(m.weight)\n    elif type(m) == nn.BatchNorm2d:\n        nn.init.constant_(m.weight, 1)\n        nn.init.constant_(m.bias, 0)","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"训练","metadata":{}},{"cell_type":"code","source":"torch.cuda.empty_cache()\nos.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:128'\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\nbatch_size=30\nsum_loss=0\nsum_loss_g=0\nsum_loss_d=0\nepoch=50\ngan=CycleGAN([(3,64),(64,128),(128,128)],[(128,128),(128,64),(64,3)],[(128,256),(256,512),(512,256),(256,128)],[(128,64),(64,32),(32,16),(16,4)],3,4*32*32,batch_size)\nloader=torch.utils.data.DataLoader(datas,batch_size=batch_size,shuffle=True)\nlosses=[]\navrange_loss=[]\nloss_g=[]\nloss_d=[]\nloss_g_avg=[]\nloss_d_avg=[]\ngan.to(device)\ngan.apply(init_weights)\nfor i in range(epoch):\n    for m,p in loader:\n        m,p=m.to(device),p.to(device)\n        f_p,f_m,reb_p,reb_m,m_t_p_r,p_t_m_r,m_t_p_f_d,p_t_m_f_d,m_t_p_f_g,p_t_m_f_g=gan(m,p)\n        target = torch.ones_like(m_t_p_f_g)#1为真\n        loss_gmtp_con=gan.g_confront_loss(torch.sigmoid(m_t_p_f_g),target)\n        target = torch.ones_like(p_t_m_f_g)\n        loss_gptm_con=gan.g_confront_loss(torch.sigmoid(p_t_m_f_g),target)\n        loss_gmtp_cyc=gan.g_cycle_loss(reb_m,m.permute(0,3,1,2))\n        loss_gptm_cyc=gan.g_cycle_loss(reb_p,p.permute(0,3,1,2))\n        target_0 = torch.ones_like(m_t_p_r)\n        target_1=torch.ones_like(m_t_p_f_d)\n        target=torch.cat((target_0, target_1), dim=0)\n        loss_dmtp=gan.g_confront_loss(torch.sigmoid(torch.cat((m_t_p_r,m_t_p_f_d),dim=0)),target)\n        target_0 = torch.ones_like(p_t_m_r)\n        target_1=torch.ones_like(p_t_m_f_d)\n        target=torch.cat((target_0, target_1), dim=0)\n        loss_dptm=gan.g_confront_loss(torch.sigmoid(torch.cat((p_t_m_r,p_t_m_f_d),dim=0)),target)\n        all_loss=loss_gmtp_con+loss_gptm_con+loss_gmtp_cyc+loss_gptm_cyc+loss_dmtp+loss_dptm\n        all_loss.backward()\n        sum_loss+=all_loss.sum()\n        sum_loss_g+=loss_gmtp_con+loss_gptm_con+loss_gmtp_cyc+loss_gptm_cyc\n        sum_loss_d+=loss_dmtp+loss_dptm\n        gan.opt_gmtp.zero_grad()\n        gan.opt_gptm.zero_grad()\n        gan.opt_dmtp.zero_grad()\n        gan.opt_dptm.zero_grad()\n        gan.opt_gmtp.step()\n        gan.opt_gptm.step()\n        gan.opt_dmtp.step()\n        gan.opt_dptm.step()\n        losses.append(all_loss.sum())\n        loss_g.append((loss_gmtp_con+loss_gptm_con+loss_gmtp_cyc+loss_gptm_cyc).sum())\n        loss_d.append((loss_dmtp+loss_dptm).sum())\n        loss_d_avg.append(sum_loss_g/len(loss_d))\n        loss_g_avg.append(sum_loss_d/len(loss_g))\n        avrange_loss.append(sum_loss/len(losses))\n        del all_loss\n        gc.collect()\n    loader=torch.utils.data.DataLoader(datas,batch_size=batch_size,shuffle=True)\nlosses=torch.tensor(losses)\navrange_loss=torch.tensor(avrange_loss)\navrange_loss_cup=avrange_loss.cpu().detach().numpy()\nlosses_cpu = losses.cpu().detach().numpy()\nloss_g=torch.tensor(loss_g)\nloss_g=loss_g.cpu().detach().numpy()\nloss_d=torch.tensor(loss_d)\nloss_d=loss_d.cpu().detach().numpy()\nloss_g_avg=torch.tensor(loss_g_avg)\nloss_g_avg=loss_g_avg.cpu().detach().numpy()\nloss_d_avg=torch.tensor(loss_d_avg)\nloss_d_avg=loss_d_avg.cpu().detach().numpy()\niterations = range(1, len(losses) + 1)\nplt.plot(iterations, losses, label='Loss')\nplt.xlabel('Iterations')\nplt.ylabel('sum_Loss')\nplt.title('Training Loss_sum')\nplt.legend()\nplt.show()\nplt.plot(iterations, avrange_loss, label='Loss')\nplt.xlabel('Iterations')\nplt.ylabel('sum_avLoss')\nplt.title('Training Loss_sum_avg')\nplt.legend()\nplt.show()\nplt.plot(iterations, loss_g, label='Loss')\nplt.xlabel('Iterations')\nplt.ylabel('Loss_g')\nplt.title('Training Loss_g')\nplt.legend()\nplt.show()\nplt.plot(iterations, loss_d, label='Loss')\nplt.xlabel('Iterations')\nplt.ylabel('Loss_d')\nplt.title('Training Loss_d')\nplt.legend()\nplt.show()\nplt.plot(iterations, loss_g_avg, label='Loss')\nplt.xlabel('Iterations')\nplt.ylabel('Loss_g_avg')\nplt.title('Training Loss_g_avg')\nplt.legend()\nplt.show()\nplt.plot(iterations, loss_d_avg, label='Loss')\nplt.xlabel('Iterations')\nplt.ylabel('Loss_d_avg')\nplt.title('Training Loss_d_avg')\nplt.legend()\nplt.show()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"torch.save(gan.state_dict(), '/kaggle/working/mymodel.pth')","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}