{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Cycle GAN","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19"}},{"cell_type":"markdown","source":"## Import Packages","metadata":{}},{"cell_type":"code","source":"import os\nimport glob\n\nfrom PIL import Image\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport itertools\n\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision import transforms as T\nfrom torchvision.utils import make_grid\n\ndef show_tensor_images(image_tensor, num_images=16, size=(1, 28, 28)):\n    '''\n    Function for visualizing images: Given a tensor of images, number of images, and\n    size per image, plots and prints the images in an uniform grid.\n    '''\n    image_shifted = (image_tensor + 1) / 2\n    image_unflat = image_tensor.detach().cpu().view(-1, *size)\n    image_grid = make_grid(image_unflat[:num_images], nrow=4)\n    plt.imshow(image_grid.permute(1, 2, 0).squeeze())\n    plt.show()\n","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.187255Z","iopub.execute_input":"2022-08-08T10:12:18.188099Z","iopub.status.idle":"2022-08-08T10:12:18.743035Z","shell.execute_reply.started":"2022-08-08T10:12:18.187995Z","shell.execute_reply":"2022-08-08T10:12:18.742307Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import torch.nn.functional as F","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.744819Z","iopub.execute_input":"2022-08-08T10:12:18.745102Z","iopub.status.idle":"2022-08-08T10:12:18.749902Z","shell.execute_reply.started":"2022-08-08T10:12:18.745057Z","shell.execute_reply":"2022-08-08T10:12:18.749186Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"DIRs = glob.glob(\"../input/gan-getting-started/*\")\nmonetTileDir = DIRs[0]\nphotoTileDir = DIRs[2]\n\nlambdaId = 5\nlambdaCycle = 10\n\nadv_criterion = nn.MSELoss() \nrecon_criterion = nn.L1Loss()\ncycle_criterion = nn.L1Loss()\n\nn_epochs = 10\ndim_A = 3\ndim_B = 3\ndisplay_step = 150\nbatch_size = 2\nlr = 0.001\nload_shape = 224\ntarget_shape = 224\ndevice = 'cuda'\n\n# pretrained = \"../input/monetgan/cycleGAN_4000.pth\npretrained = None","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.751197Z","iopub.execute_input":"2022-08-08T10:12:18.751990Z","iopub.status.idle":"2022-08-08T10:12:18.762752Z","shell.execute_reply.started":"2022-08-08T10:12:18.751954Z","shell.execute_reply":"2022-08-08T10:12:18.761944Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(DIRs)","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.764613Z","iopub.execute_input":"2022-08-08T10:12:18.766115Z","iopub.status.idle":"2022-08-08T10:12:18.772059Z","shell.execute_reply.started":"2022-08-08T10:12:18.766086Z","shell.execute_reply":"2022-08-08T10:12:18.771369Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Data Preparation","metadata":{}},{"cell_type":"code","source":"print(f\"Numble of monet images : {len(glob.glob(f'{monetTileDir}/*.jpg'))}\")\nprint(f\"Numble of photo images : {len(glob.glob(f'{photoTileDir}/*.jpg'))}\")\n","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.773369Z","iopub.execute_input":"2022-08-08T10:12:18.773615Z","iopub.status.idle":"2022-08-08T10:12:18.802769Z","shell.execute_reply.started":"2022-08-08T10:12:18.773583Z","shell.execute_reply":"2022-08-08T10:12:18.801685Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class MonetJPGDataset(Dataset):\n    \"\"\"\n    MonetDataset Class\n    \n    \"\"\"\n    def __init__(self, n_samples, monetDir=None, photoDir=None, mode='train'):\n        super(MonetJPGDataset, self).__init__()\n        self.monetList = glob.glob(f\"{monetDir}/*.jpg\")\n        self.photoList = glob.glob(f\"{photoDir}/*.jpg\")\n        self.n_samples = n_samples\n#         self.transform = self.get_transform(mode)\n\n    def __len__(self):\n        return self.n_samples\n    \n    def __getitem__(self, index):\n        monetImage = Image.open(self.monetList[index % len(self.monetList)])\n        photoImage = Image.open(self.photoList[index % len(self.photoList)])\n        monetTensor = T.ToTensor()(monetImage)\n        photoTensor = T.ToTensor()(photoImage)\n        return monetTensor, photoTensor\n    \n    def get_transform(self, mode):\n        transform = T.Compose([\n                           T.Resize(int(args.image_size * 1.12), Image.BICUBIC),\n                           T.RandomCrop(args.image_size),\n                           T.RandomHorizontalFlip(),\n                           T.ToTensor(),\n                           T.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n        return transform","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.804088Z","iopub.execute_input":"2022-08-08T10:12:18.804339Z","iopub.status.idle":"2022-08-08T10:12:18.813323Z","shell.execute_reply.started":"2022-08-08T10:12:18.804307Z","shell.execute_reply":"2022-08-08T10:12:18.812198Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Cycle GAN","metadata":{}},{"cell_type":"code","source":"## Utility crop function\ndef crop(image, new_shape):\n    \"\"\"\n    Function for cropping an image tensor. Center crop\n    \"\"\"\n    old_h, old_w = image.shape[-2:]\n    new_h, new_w = new_shape[-2:]\n    back_h = (old_h - new_h) // 2\n    div_h = (old_h - new_h) % 2\n    back_w = (old_w - new_w) // 2\n    div_w = (old_w - new_w) % 2\n#     print(back_h, div_h)\n    return image[..., back_h:-back_h-div_h, back_w:-back_w-div_w]","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.814819Z","iopub.execute_input":"2022-08-08T10:12:18.815065Z","iopub.status.idle":"2022-08-08T10:12:18.825459Z","shell.execute_reply.started":"2022-08-08T10:12:18.815033Z","shell.execute_reply":"2022-08-08T10:12:18.824492Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class ContractingBlk(nn.Module):\n    def __init__(self, in_chans, use_bn=True, kernel_size=3, activation='relu'):\n        # Image size = h, w\n        super(ContractingBlk, self).__init__()\n        self.conv1 = nn.Conv2d(in_chans, in_chans * 2, kernel_size=3, padding=1)\n        self.conv2 = nn.Conv2d(in_chans * 2, in_chans * 2, kernel_size=3, padding=1)\n        self.pool = nn.AvgPool2d(kernel_size=2, stride=2) \n        self.activation = nn.ReLU() if activation == 'relu' else nn.LeakyReLU(0.2)\n        if use_bn:\n            self.instancenorm = nn.InstanceNorm2d(in_chans * 2)\n        self.use_bn = use_bn\n    \n    def forward(self, x):\n        x = self.conv1(x)\n        x = self.activation(x)\n        x = self.conv2(x)\n        if self.use_bn:\n            x = self.instancenorm(x)\n        x = self.activation(x)\n        x = self.pool(x)\n        return x\n\n\nclass ResidualBlk(nn.Module):\n    def __init__(self, in_chans, drop_out=0.1):\n        super(ResidualBlk, self).__init__()\n        self.conv1 = nn.Conv2d(in_chans, in_chans, kernel_size=3, padding=1, padding_mode='reflect')\n        self.norm1 = nn.InstanceNorm2d(in_chans)\n        self.drop1 = nn.Dropout(drop_out)\n        self.conv2 = nn.Conv2d(in_chans, in_chans, kernel_size=3, padding=1, padding_mode='reflect')\n        self.norm2 = nn.InstanceNorm2d(in_chans)\n        self.drop2 = nn.Dropout(drop_out)\n        self.activation = nn.LeakyReLU(0.2)\n    \n    def forward(self, x):\n        originx = x.clone()\n        x = self.conv1(x)\n        x = self.norm1(x)\n        x = self.drop1(x)\n        x = self.activation(x)\n        x = self.conv2(x)\n        x = self.norm2(x)\n        x = self.drop2(x)\n        return originx + x\n    \n\nclass ExpandingBlk(nn.Module):\n    def __init__(self, in_chans, drop_out=0.1):\n        super(ExpandingBlk, self).__init__()\n        # Image size = h, w\n        self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True)\n        self.conv1 = nn.Conv2d(in_chans, in_chans // 2, kernel_size=3, padding=1)\n        self.norm1 = nn.InstanceNorm2d(in_chans//2)\n        self.drop1 = nn.Dropout(drop_out)\n        self.conv2 = nn.Conv2d(in_chans, in_chans // 2, kernel_size=3, padding=1)\n        self.norm2 = nn.InstanceNorm2d(in_chans//2)\n        self.drop2 = nn.Dropout(drop_out)\n        self.activation = nn.LeakyReLU(0.2)\n\n    def forward(self, x, skip_con_x):\n        x = self.upsample(x)\n        x = self.conv1(x)\n        x = self.norm1(x)\n        x = self.drop1(x)\n        x = torch.cat([x, skip_con_x], axis=1)\n        x = self.conv2(x)\n        x = self.norm2(x)\n        x = self.drop2(x)\n        x = self.activation(x)\n        return x\n    \n\nclass FeatureMapBlk(nn.Module):\n    def __init__(self, in_chans, out_chans):\n        super(FeatureMapBlk, self).__init__()\n        self.conv = nn.Conv2d(in_chans, out_chans, kernel_size=1)\n    \n    def forward(self, x):\n        return self.conv(x)\n\n    \nclass Generator(nn.Module):\n    def __init__(self, in_chans, out_chans, hidden_chans=64):\n        super(Generator, self).__init__()\n        self.upfeature = FeatureMapBlk(in_chans, hidden_chans)\n        self.contract1 = ContractingBlk(hidden_chans)\n        self.contract2 = ContractingBlk(hidden_chans * 2)\n        self.contract3 = ContractingBlk(hidden_chans * 4)\n        self.resPath = nn.Sequential(\n            ResidualBlk(hidden_chans * 8),\n            ResidualBlk(hidden_chans * 8)\n        )\n        self.expand1 = ExpandingBlk(hidden_chans * 8)\n        self.expand2 = ExpandingBlk(hidden_chans * 4)\n        self.expand3 = ExpandingBlk(hidden_chans * 2)\n        self.downfeature = FeatureMapBlk(hidden_chans, out_chans)\n\n    def forward(self, x):\n        '''\n        Function for completing a forward pass of UNet: \n        Given an image tensor, passes it through U-Net and returns the output.\n        Parameters:\n            x: image tensor of shape (batch size, channels, height, width)\n        '''\n        x0 = self.upfeature(x)\n        x1 = self.contract1(x0)\n        x2 = self.contract2(x1)\n        x3 = self.contract3(x2)\n        x4 = self.resPath(x3)\n        x5 = self.expand1(x4, x2)\n        x6 = self.expand2(x5, x1)\n        x7 = self.expand3(x6, x0)\n        xn = self.downfeature(x7)\n        return xn","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.827847Z","iopub.execute_input":"2022-08-08T10:12:18.828429Z","iopub.status.idle":"2022-08-08T10:12:18.851001Z","shell.execute_reply.started":"2022-08-08T10:12:18.828395Z","shell.execute_reply":"2022-08-08T10:12:18.850119Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"class Discriminator(nn.Module):\n    def __init__(self, input_channels, hidden_channels=64):\n        super(Discriminator, self).__init__()\n        self.upfeature = FeatureMapBlk(input_channels, hidden_channels)\n        self.contract1 = ContractingBlk(hidden_channels, use_bn=False, kernel_size=4, activation='lrelu')\n        self.contract2 = ContractingBlk(hidden_channels * 2, kernel_size=4, activation='lrelu')\n        self.contract3 = ContractingBlk(hidden_channels * 4, kernel_size=4, activation='lrelu')\n        self.final = nn.Conv2d(hidden_channels * 8, 1, kernel_size=1)\n\n    def forward(self, x):\n        x0 = self.upfeature(x)\n        x1 = self.contract1(x0)\n        x2 = self.contract2(x1)\n        x3 = self.contract3(x2)\n        xn = self.final(x3)\n        return xn","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.852801Z","iopub.execute_input":"2022-08-08T10:12:18.853299Z","iopub.status.idle":"2022-08-08T10:12:18.864377Z","shell.execute_reply.started":"2022-08-08T10:12:18.853240Z","shell.execute_reply":"2022-08-08T10:12:18.863446Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Loss Functions","metadata":{}},{"cell_type":"markdown","source":"### Reconstruction Loss - Identity Loss","metadata":{}},{"cell_type":"markdown","source":"### Cycle Consistency Loss\n\n![image.png](attachment:f2a82af8-334d-4894-aea3-ce9e3a5878ac.png)","metadata":{},"attachments":{"f2a82af8-334d-4894-aea3-ce9e3a5878ac.png":{"image/png":"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"}}},{"cell_type":"code","source":"def get_disc_loss(real_X, fake_X, disc_X, adv_criterion):\n    real_pred = disc_X(real_X)\n    fake_pred = disc_X(fake_X.detach())\n    disc_loss = 1/2 * (adv_criterion(real_pred, torch.ones_like(real_pred)) + adv_criterion(fake_pred, torch.zeros_like(fake_pred)))\n    return disc_loss\n\ndef get_gen_adversarial_loss(real_X, disc_Y, gen_XY, adv_criterion):\n    '''\n    Return the adversarial loss of the generator given inputs\n    (and the generated images for testing purposes).\n    '''\n    fake_Y = gen_XY(real_X)\n    fake_y_pred = disc_Y(fake_Y)\n    adversarial_loss = adv_criterion(fake_y_pred, torch.ones_like(fake_y_pred))\n    return adversarial_loss, fake_Y\n\n\ndef get_identity_loss(real_X, gen_YX, identity_criterion):\n    identity_X = gen_YX(real_X)\n    identity_loss = identity_criterion(real_X, identity_X)\n    return identity_loss, identity_X\n\ndef get_cycle_consistency_loss(real_X, fake_Y, gen_YX, cycle_criterion):\n    '''\n    Return the cycle consistency loss of the generator given inputs\n    (and the generated images for testing purposes).\n    '''\n    cycle_X = gen_YX(fake_Y)\n    cycle_loss = cycle_criterion(real_X, cycle_X)\n    return cycle_loss, cycle_X\n\ndef get_gen_loss(real_A, real_B, gen_AB, gen_BA, disc_A, disc_B, adv_criterion, identity_criterion, cycle_criterion, lambda_identity=0.1, lambda_cycle=10):\n    '''\n    Return the loss of the generator given inputs.\n    '''\n    adv_loss_AB, fake_B = get_gen_adversarial_loss(real_A, disc_B, gen_AB, adv_criterion)\n    adv_loss_BA, fake_A = get_gen_adversarial_loss(real_B, disc_A, gen_BA, adv_criterion)\n    adv_loss = (adv_loss_AB + adv_loss_BA) / 2\n    # Identity Loss -- get_identity_loss(real_X, gen_YX, identity_criterion)\n    identity_loss_AB, identity_A = get_identity_loss(real_A, gen_BA, identity_criterion)\n    identity_loss_BA, identity_B = get_identity_loss(real_B, gen_AB, identity_criterion)\n    identity_loss = (identity_loss_AB + identity_loss_BA) / 2\n    # Cycle-consistency Loss -- get_cycle_consistency_loss(real_X, fake_Y, gen_YX, cycle_criterion)\n    cycle_loss_AB, cycle_A = get_cycle_consistency_loss(real_A, fake_B, gen_BA, cycle_criterion)\n    cycle_loss_BA, cycle_B = get_cycle_consistency_loss(real_B, fake_A, gen_AB, cycle_criterion)\n    cycle_loss = (cycle_loss_AB + cycle_loss_BA) / 2\n    # Total loss\n    gen_loss = adv_loss + lambda_identity * identity_loss + lambda_cycle * cycle_loss\n    return gen_loss, fake_A, fake_B","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.868104Z","iopub.execute_input":"2022-08-08T10:12:18.868476Z","iopub.status.idle":"2022-08-08T10:12:18.881634Z","shell.execute_reply.started":"2022-08-08T10:12:18.868448Z","shell.execute_reply":"2022-08-08T10:12:18.880750Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"gen_AB = Generator(dim_A, dim_B).to(device)\ngen_BA = Generator(dim_B, dim_A).to(device)\ndisc_A = Discriminator(dim_A).to(device)\ndisc_B = Discriminator(dim_B).to(device)\n# gen_AB = Generator().to(device)\n# gen_BA = Generator().to(device)\n# disc_A = Discriminator().to(device)\n# disc_B = Discriminator().to(device)\n\ndef weights_init(m):\n    if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):\n        torch.nn.init.normal_(m.weight, 0.0, 0.02)\n    if isinstance(m, nn.BatchNorm2d):\n        torch.nn.init.normal_(m.weight, 0.0, 0.02)\n        torch.nn.init.constant_(m.bias, 0)\n\nif pretrained:\n    checkpoint = torch.load(pretrained)\n    gen_AB.load_state_dict(checkpoint[\"gen_AB\"])\n    gen_BA.load_state_dict(checkpoint[\"gen_BA\"])\n    disc_A.load_state_dict(checkpoint[\"disc_A\"])\n    disc_B.load_state_dict(checkpoint[\"disc_B\"])\nelse:  \n    gen_AB = gen_AB.apply(weights_init)\n    gen_BA = gen_BA.apply(weights_init)\n    disc_A = disc_A.apply(weights_init)\n    disc_B = disc_B.apply(weights_init)\n\ndisc_B_opt = torch.optim.Adam(disc_B.parameters(), lr=lr, betas=(0.5, 0.999), weight_decay=1e-4, eps=1e-8)\ngen_opt = torch.optim.Adam(list(gen_AB.parameters()) + list(gen_BA.parameters()), lr=lr, betas=(0.5, 0.999), weight_decay=1e-4, eps=1e-8)\ndisc_A_opt = torch.optim.Adam(disc_A.parameters(), lr=lr, betas=(0.5, 0.999), weight_decay=1e-4, eps=1e-8)\n    \ndataset = MonetJPGDataset(7000, monetDir=monetTileDir, photoDir=photoTileDir, mode='train')\nfrom torch.utils.data import DataLoader\ndataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:18.882802Z","iopub.execute_input":"2022-08-08T10:12:18.883068Z","iopub.status.idle":"2022-08-08T10:12:21.125086Z","shell.execute_reply.started":"2022-08-08T10:12:18.883032Z","shell.execute_reply":"2022-08-08T10:12:21.124321Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from skimage import color\nfrom tqdm import tqdm\nimport numpy as np\nplt.rcParams[\"figure.figsize\"] = (10, 10)\n\n\ndef train(save_model=True):\n    mean_generator_loss = 0\n    mean_discriminator_loss = 0\n    cur_step = 0\n    for epoch in range(n_epochs):\n        with tqdm(dataloader) as t:\n            t.set_description(f\"Training:Epo[{epoch}]\")\n            for i, (real_A, real_B) in enumerate(t):\n                # image_width = image.shape[3]\n                real_A = nn.functional.interpolate(real_A, size=target_shape)\n                real_B = nn.functional.interpolate(real_B, size=target_shape)\n                cur_batch_size = len(real_A)\n                real_A = real_A.to(device)\n                real_B = real_B.to(device)\n\n                ### Update discriminator A ###\n                disc_A_opt.zero_grad() # Zero out the gradient before backpropagation\n                with torch.no_grad():\n                    fake_A = gen_BA(real_B)\n                disc_A_loss = get_disc_loss(real_A, fake_A, disc_A, adv_criterion)\n                disc_A_loss.backward(retain_graph=True) # Update gradients\n                disc_A_opt.step() # Update optimizer\n\n                ### Update discriminator B ###\n                disc_B_opt.zero_grad() # Zero out the gradient before backpropagation\n                with torch.no_grad():\n                    fake_B = gen_AB(real_A)\n                disc_B_loss = get_disc_loss(real_B, fake_B, disc_B, adv_criterion)\n                disc_B_loss.backward(retain_graph=True) # Update gradients\n                disc_B_opt.step() # Update optimizer\n\n                ### Update generator ###\n                gen_opt.zero_grad()\n                gen_loss, fake_A, fake_B = get_gen_loss(\n                    real_A, real_B, gen_AB, gen_BA, disc_A, disc_B, adv_criterion, recon_criterion, cycle_criterion,\n                    lambda_identity=lambdaId,\n                    lambda_cycle=lambdaCycle\n                )\n                gen_loss.backward() # Update gradients\n                gen_opt.step() # Update optimizer\n\n                # Keep track of the average discriminator loss\n                mean_discriminator_loss += disc_A_loss.item() / display_step\n                # Keep track of the average generator loss\n                mean_generator_loss += gen_loss.item() / display_step\n\n                ### Visualization code ###\n                if cur_step % display_step == 0:\n                    print(f\"Epoch {epoch}: Step {cur_step}: Generator (U-Net) loss: {mean_generator_loss}, Discriminator loss: {mean_discriminator_loss}\")\n                    show_tensor_images(torch.cat([real_A, real_B]), size=(dim_A, target_shape, target_shape))\n                    show_tensor_images(torch.cat([fake_B, fake_A]), size=(dim_B, target_shape, target_shape))\n                    mean_generator_loss = 0\n                    mean_discriminator_loss = 0\n                    # You can change save_model to True if you'd like to save the model\n                    if save_model:\n                        torch.save({\n                            'gen_AB': gen_AB.state_dict(),\n                            'gen_BA': gen_BA.state_dict(),\n                            'gen_opt': gen_opt.state_dict(),\n                            'disc_A': disc_A.state_dict(),\n                            'disc_A_opt': disc_A_opt.state_dict(),\n                            'disc_B': disc_B.state_dict(),\n                            'disc_B_opt': disc_B_opt.state_dict()\n                        }, f\"cycleGAN_{cur_step}.pth\")\n                cur_step += 1\n                t.set_postfix(Gen_loss=f\"{gen_loss.item():.4f}\", Disc_loss=f\"{disc_A_loss.item():.4f}\")\n\n\ndef training(save_model=True):\n    gen_loss = 0\n    disc_loss = 0\n    curr_step = 0\n    ","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:21.126366Z","iopub.execute_input":"2022-08-08T10:12:21.126625Z","iopub.status.idle":"2022-08-08T10:12:21.220954Z","shell.execute_reply.started":"2022-08-08T10:12:21.126591Z","shell.execute_reply":"2022-08-08T10:12:21.219957Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train()","metadata":{"execution":{"iopub.status.busy":"2022-08-08T10:12:21.222373Z","iopub.execute_input":"2022-08-08T10:12:21.222943Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"torch.cuda.empty_cache()","metadata":{"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}