scene-evo-hwacc.ipynb

{"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":"nvidiaTeslaT4","dataSources":[{"sourceId":7663250,"sourceType":"datasetVersion","datasetId":4468671}],"dockerImageVersionId":30648,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import torch #GPUs: NVIDIA Tesla T4 x2\nif torch.cuda.is_available():\n    device1 = torch.device(\"cuda:0\")\n    print(f\"GPU found: {torch.cuda.get_device_name(0)}\")\n    properties1 = torch.cuda.get_device_properties(device1)\n    no_cudacores1 = properties1.multi_processor_count *64\n    print(f\"{no_cudacores1} CUDA cores on GPU\")\n    device2 = torch.device(\"cuda:1\")\n    print(f\"GPU found: {torch.cuda.get_device_name(1)}\")\n    properties2 = torch.cuda.get_device_properties(device2)\n    no_cudacores2 = properties2.multi_processor_count *64\n    print(f\"{no_cudacores2} CUDA cores on GPU\")\nelse:\n    device = torch.device(\"cpu\")\n    print(\"No GPU found! using CPU\")","metadata":{"_uuid":"5e5565d0-0a9c-41d3-8a0e-6333d7c83ef3","_cell_guid":"eaaf7e80-923b-4d3b-bb45-a377ec6ac4d8","collapsed":false,"jupyter":{"outputs_hidden":false},"execution":{"iopub.status.busy":"2024-08-09T07:52:56.323306Z","iopub.execute_input":"2024-08-09T07:52:56.323676Z","iopub.status.idle":"2024-08-09T07:52:56.331418Z","shell.execute_reply.started":"2024-08-09T07:52:56.323649Z","shell.execute_reply":"2024-08-09T07:52:56.330406Z"},"trusted":true},"execution_count":24,"outputs":[{"name":"stdout","text":"GPU found: Tesla T4\n2560 CUDA cores on GPU\nGPU found: Tesla T4\n2560 CUDA cores on GPU\n","output_type":"stream"}]},{"cell_type":"code","source":"%%capture\ntry:#libraries\n    import torch\n    import torch.nn as nn\n    import torch.nn.functional as F\n    import optim as optim\n    from torch.optim import Adam\nexcept Exception as e:\n    !pip install optim\n    import torch\n    import torch.nn as nn\n    import torch.nn.functional as F\n    import optim as optim\n    from torch.optim import Adam","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:56.333040Z","iopub.execute_input":"2024-08-09T07:52:56.333737Z","iopub.status.idle":"2024-08-09T07:52:56.346647Z","shell.execute_reply.started":"2024-08-09T07:52:56.333709Z","shell.execute_reply":"2024-08-09T07:52:56.345798Z"},"trusted":true},"execution_count":25,"outputs":[]},{"cell_type":"code","source":"%%capture\ntry:#nuscenes-devkit\n    %matplotlib inline\n    from nuscenes.nuscenes import NuScenes\nexcept Exception as e:\n    !pip install nuscenes-devkit\n    %matplotlib inline\n    from nuscenes.nuscenes import NuScenes","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:56.348276Z","iopub.execute_input":"2024-08-09T07:52:56.348569Z","iopub.status.idle":"2024-08-09T07:52:56.359732Z","shell.execute_reply.started":"2024-08-09T07:52:56.348546Z","shell.execute_reply":"2024-08-09T07:52:56.358948Z"},"trusted":true},"execution_count":26,"outputs":[]},{"cell_type":"code","source":"import os\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom nuscenes.utils.data_classes import LidarPointCloud\n#for each file/instance of observation\ndirectory = '/kaggle/input/multislow-poli/CAVALIER_MULTI-SLOW-POLI/sweeps/LIDAR_FUSED'\nsave = r'/kaggle/working/'\nfiles = sorted(os.listdir(directory))\nprint(files[0])\npcdpath = os.path.join(directory, files[700])\npcd = LidarPointCloud.from_file(pcdpath)\n#print(pcd.points)\n#extract feature coordiantes from pcd\npcd4d = torch.tensor(pcd.points[:,:], dtype=torch.float32)\n#print(pcd4d)\nin_neurons = pcd4d.shape[1]\nprint(in_neurons)\n#moving to gpu here\npcd4d_gpu = pcd4d.to('cuda:0')\nprint(pcd4d_gpu)\n#extract lidar pcd\ndef extract_pcd(directory, ifile):\n    pcdpath = os.path.join(directory, ifile)\n    pcd = LidarPointCloud.from_file(pcdpath)\n    pcd4d = torch.tensor(pcd.points[:,:], dtype=torch.float32)\n    return pcd4d","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:56.360763Z","iopub.execute_input":"2024-08-09T07:52:56.361016Z","iopub.status.idle":"2024-08-09T07:52:56.391384Z","shell.execute_reply.started":"2024-08-09T07:52:56.360993Z","shell.execute_reply":"2024-08-09T07:52:56.390548Z"},"trusted":true},"execution_count":27,"outputs":[{"name":"stdout","text":"MULTI-SLOW-POLI__LIDAR_FUSED__1641334199802608110.pcd.bin\n76380\ntensor([[-3.5002e+00, -3.4870e+00, -3.4423e+00,  ...,  4.9874e+00,\n          4.9438e+00,  4.9427e+00],\n        [ 8.0858e+00,  8.1075e+00,  8.0821e+00,  ..., -4.6150e+00,\n         -4.5686e+00, -4.5918e+00],\n        [ 1.0760e+00,  1.0766e+00,  1.0742e+00,  ..., -1.9704e-01,\n         -1.9057e-01, -1.9291e-01],\n        [ 2.4805e-01,  2.3291e-01,  2.5098e-01,  ...,  1.7627e-01,\n          2.0508e-02,  1.9531e-03]], device='cuda:0')\n","output_type":"stream"}]},{"cell_type":"code","source":"#BEV map creation on GPU for one scan\ndef convert_scan_bevmap(pcd4d, resolution, bev_map_size, gpu):#resolution is also voxwel size\n    pcd4d_gpu = pcd4d.to(gpu)\n    threshold = 0\n    #extract x,y,z\n    x = pcd4d_gpu[0,:]\n    y = pcd4d_gpu[1,:]\n    z = pcd4d_gpu[2,:]\n    #print(x)\n    #initialize an empty BEV map\n    bev_map = torch.zeros((bev_map_size, bev_map_size), device=gpu)\n    #convert point cloud to BEV map\n    #Calculate the corresponding pixel for each point in the point cloud\n    pixelx = ((x / resolution) + bev_map_size / 2).floor().long() #shifting origins\n    pixely = ((y / resolution) + bev_map_size / 2).floor().long()\n    #Ignore points that fall outside the BEV map\n    mask = (pixelx >= 0) & (pixelx < bev_map_size) & (pixely >= 0) & (pixely < bev_map_size)\n    #Update the BEV map (using max pooling here, but can also use average pooling or other methods)\n    bev_map[pixelx[mask], pixely[mask]] = torch.max(bev_map[pixelx[mask], pixely[mask]], z[mask])\n    bev_map = torch.where(bev_map > threshold, torch.tensor(1.0, device=bev_map.device), torch.tensor(0.0, device=bev_map.device))\n    return bev_map#returning binary bev map\n\nbevmap = convert_scan_bevmap(pcd4d, 0.2, 1000, device1)\nprint(bevmap.shape)\n# Plot the BEV map\nplt.imshow(bevmap.cpu(), cmap='hot')\nplt.show()\nprint(bevmap.max())","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:56.393069Z","iopub.execute_input":"2024-08-09T07:52:56.393342Z","iopub.status.idle":"2024-08-09T07:52:56.632068Z","shell.execute_reply.started":"2024-08-09T07:52:56.393302Z","shell.execute_reply":"2024-08-09T07:52:56.631209Z"},"trusted":true},"execution_count":28,"outputs":[{"name":"stdout","text":"torch.Size([1000, 1000])\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"name":"stdout","text":"tensor(1., device='cuda:0')\n","output_type":"stream"}]},{"cell_type":"code","source":"class pyramidnetwork(nn.Module):\n    def __init__(self):\n        super(pyramidnetwork, self).__init__()\n        ##### encoder\n        self.conv1 = nn.Conv2d(16,32,1,1)\n        self.bn1 = nn.BatchNorm2d(32)\n        self.conv1_1 = nn.Conv2d(32,32,3,1,1)\n        self.bn1_1 = nn.BatchNorm2d(32)\n        self.poolconv1 = nn.Conv2d(32,32,3,1,1)\n        self.poolbn1 = nn.BatchNorm2d(32)\n        \n        self.conv2 = nn.Conv2d(32,64,3,1,1)\n        self.bn2 = nn.BatchNorm2d(64)\n        self.conv2_1 = nn.Conv2d(64,64,3,1,1)\n        self.bn2_1 = nn.BatchNorm2d(64)\n        self.poolconv2 = nn.Conv2d(64,64,3,1,1)\n        self.poolbn2 = nn.BatchNorm2d(64)\n        \n        self.conv3 = nn.Conv2d(64,128,3,1,1)\n        self.bn3 = nn.BatchNorm2d(128)\n        self.conv3_1 = nn.Conv2d(128,128,3,1,1)\n        self.bn3_1 = nn.BatchNorm2d(128)\n        self.poolconv3 = nn.Conv2d(128,128,3,1,1)\n        self.poolbn3 = nn.BatchNorm2d(128)\n        \n        self.conv4 = nn.Conv2d(128,256,3,1,1)\n        self.bn4 = nn.BatchNorm2d(256)\n        self.conv4_1 = nn.Conv2d(256,256,3,1,1)\n        self.bn4_1 = nn.BatchNorm2d(256)\n        self.poolconv4 = nn.Conv2d(256,256,3,1,1)\n        self.poolbn4 = nn.BatchNorm2d(256)\n        \n        self.conv5 = nn.Conv2d(256,512,3,1,1)\n        self.bn5 = nn.BatchNorm2d(512)\n        self.conv5_1 = nn.Conv2d(512,512,3,1,1)\n        self.bn5_1 = nn.BatchNorm2d(512)\n        self.poolconv5 = nn.Conv2d(512,512,3,1,1)\n        self.poolbn5 = nn.BatchNorm2d(512)\n        \n        self.conv6 = nn.Conv2d(512,1024,3,1,1)\n        self.bn6 = nn.BatchNorm2d(1024)\n        self.conv6_1 = nn.Conv2d(1024,1024,3,1,1)\n        self.bn6_1 = nn.BatchNorm2d(1024)\n        self.poolconv6 = nn.Conv2d(1024,1024,3,1,1)\n        self.poolbn6 = nn.BatchNorm2d(1024)\n        ##### decoder\n        self.tranconv6 = nn.ConvTranspose2d(1024,512,3,2)\n        self.tranbn6 = nn.BatchNorm2d(512)\n        self.upconv6 = nn.ConvTranspose2d(1024,512,3,1,1)\n        self.upbn6 = nn.BatchNorm2d(512)\n        self.upconv6_1 = nn.ConvTranspose2d(512,512,3,1,1)\n        self.upbn6_1 = nn.BatchNorm2d(512)\n        \n        self.tranconv5 = nn.ConvTranspose2d(512,256,2,2)\n        self.tranbn5 = nn.BatchNorm2d(256)\n        self.upconv5 = nn.ConvTranspose2d(512,256,3,1,1)\n        self.upbn5 = nn.BatchNorm2d(256)\n        self.upconv5_1 = nn.ConvTranspose2d(256,256,3,1,1)\n        self.upbn5_1 = nn.BatchNorm2d(256)\n        \n        self.tranconv4 = nn.ConvTranspose2d(256,128,3,2)\n        self.tranbn4 = nn.BatchNorm2d(128)\n        self.upconv4 = nn.ConvTranspose2d(256,128,3,1,1)\n        self.upbn4 = nn.BatchNorm2d(128)\n        self.upconv4_1 = nn.ConvTranspose2d(128,128,3,1,1)\n        self.upbn4_1 = nn.BatchNorm2d(128)\n        \n        self.tranconv3 = nn.ConvTranspose2d(128,64,2,2)\n        self.tranbn3 = nn.BatchNorm2d(64)\n        self.upconv3 = nn.ConvTranspose2d(128,64,3,1,1)\n        self.upbn3 = nn.BatchNorm2d(64)\n        self.upconv3_1 = nn.ConvTranspose2d(64,64,3,1,1)\n        self.upbn3_1 = nn.BatchNorm2d(64)\n        \n        self.tranconv2 = nn.ConvTranspose2d(64,32,2,2)\n        self.tranbn2 = nn.BatchNorm2d(32)\n        self.upconv2 = nn.ConvTranspose2d(64,32,3,1,1)\n        self.upbn2 = nn.BatchNorm2d(32)\n        self.upconv2_1 = nn.ConvTranspose2d(32,32,3,1,1)\n        self.upbn2_1 = nn.BatchNorm2d(32)\n        \n        self.tranconv1 = nn.ConvTranspose2d(32,16,2,2)\n        self.tranbn1 = nn.BatchNorm2d(16)\n        self.upconv1 = nn.ConvTranspose2d(32,16,1,1)\n        self.upbn1 = nn.BatchNorm2d(16)\n        self.upconv1_1 = nn.ConvTranspose2d(16,1,3,1,1)\n        self.upbn1_1 = nn.BatchNorm2d(1)\n        \n        self.maxpool = nn.MaxPool2d(kernel_size=2,stride=2)\n    def forward(self, pastscans,currscan):\n        #stack scans\n        xbevs = pastscans + [currscan]\n        xbevs_stack = torch.stack(xbevs)\n        xbevs_stack = xbevs_stack.float()\n        xbevs_ten = xbevs_stack.unsqueeze(0)\n        #print(xbevs_ten.shape)\n        #encoding\n        x1 = F.leaky_relu(self.bn1(self.conv1(xbevs_ten)),negative_slope=0.01)\n        x1 = F.leaky_relu(self.bn1_1(self.conv1_1(x1)),negative_slope=0.01)\n        x_1 = self.maxpool(x1)\n        x_1 = F.leaky_relu(self.poolbn1(self.poolconv1(x_1)),negative_slope=0.01)\n        x1 = self.maxpool(x1)\n\n        x2 = F.leaky_relu(self.bn2(self.conv2(x1)),negative_slope=0.01)\n        x2 = F.leaky_relu(self.bn2_1(self.conv2_1(x2)),negative_slope=0.01)\n        x_2 = self.maxpool(x2)\n        x_2 = F.leaky_relu(self.poolbn2(self.poolconv2(x_2)),negative_slope=0.01)\n        x2 = self.maxpool(x2)\n\n        x3 = F.leaky_relu(self.bn3(self.conv3(x2)),negative_slope=0.01)\n        x3 = F.leaky_relu(self.bn3_1(self.conv3_1(x3)),negative_slope=0.01)\n        x_3 = self.maxpool(x3)\n        x_3 = F.leaky_relu(self.poolbn3(self.poolconv3(x_3)),negative_slope=0.01)\n        x3 = self.maxpool(x3)\n        \n        x4 = F.leaky_relu(self.bn4(self.conv4(x3)),negative_slope=0.01)\n        x4 = F.leaky_relu(self.bn4_1(self.conv4_1(x4)),negative_slope=0.01)\n        x_4 = self.maxpool(x4)\n        x_4 = F.leaky_relu(self.poolbn4(self.poolconv4(x_4)),negative_slope=0.01)\n        x4 = self.maxpool(x4)\n\n        x5 = F.leaky_relu(self.bn5(self.conv5(x4)),negative_slope=0.01)\n        x5 = F.leaky_relu(self.bn5_1(self.conv5_1(x5)),negative_slope=0.01)\n        x_5 = self.maxpool(x5)\n        x_5 = F.leaky_relu(self.poolbn5(self.poolconv5(x_5)),negative_slope=0.01)\n        x5 = self.maxpool(x5)\n        \n        x6 = F.leaky_relu(self.bn6(self.conv6(x5)),negative_slope=0.01)\n        x6 = F.leaky_relu(self.bn6_1(self.conv6_1(x6)),negative_slope=0.01)\n        x_6 = self.maxpool(x6)\n        x_6 = F.leaky_relu(self.poolbn6(self.poolconv6(x_6)),negative_slope=0.01)\n        #decoding\n        x6up = F.leaky_relu(self.tranbn6(self.tranconv6(x_6)),negative_slope=0.01)\n        x6cat = torch.cat((x6up, x_5), dim=1)\n        x6de = F.leaky_relu(self.upbn6(self.upconv6(x6cat)),negative_slope=0.01)\n        x6de = F.leaky_relu(self.upbn6_1(self.upconv6_1(x6de)),negative_slope=0.01)\n        \n        x5up = F.leaky_relu(self.tranbn5(self.tranconv5(x_5)),negative_slope=0.01)\n        x5cat = torch.cat((x5up, x_4), dim=1)\n        x5de = F.leaky_relu(self.upbn5(self.upconv5(x5cat)),negative_slope=0.01)\n        x5de = F.leaky_relu(self.upbn5_1(self.upconv5_1(x5de)),negative_slope=0.01)\n\n        x4up = F.leaky_relu(self.tranbn4(self.tranconv4(x_4)),negative_slope=0.01)\n        x4cat = torch.cat((x4up, x_3), dim=1)\n        x4de = F.leaky_relu(self.upbn4(self.upconv4(x4cat)),negative_slope=0.01)\n        x4de = F.leaky_relu(self.upbn4_1(self.upconv4_1(x4de)),negative_slope=0.01)\n        \n        x3up = F.leaky_relu(self.tranbn3(self.tranconv3(x_3)),negative_slope=0.01)\n        x3cat = torch.cat((x3up, x_2), dim=1)\n        x3de = F.leaky_relu(self.upbn3(self.upconv3(x3cat)),negative_slope=0.01)\n        x3de = F.leaky_relu(self.upbn3_1(self.upconv3_1(x3de)),negative_slope=0.01)\n\n        x2up = F.leaky_relu(self.tranbn2(self.tranconv2(x_2)),negative_slope=0.01)\n        x2cat = torch.cat((x2up, x_1), dim=1)\n        x2de = F.leaky_relu(self.upbn2(self.upconv2(x2cat)),negative_slope=0.01)\n        x2de = F.leaky_relu(self.upbn2_1(self.upconv2_1(x2de)),negative_slope=0.01)\n\n        x1up = F.leaky_relu(self.tranbn1(self.tranconv1(x_1)),negative_slope=0.01)\n        x1cat = torch.cat((x1up, xbevs_ten), dim=1)\n        x1de = F.leaky_relu(self.upbn1(self.upconv1(x1cat)),negative_slope=0.01)\n        x1de = F.leaky_relu(self.upbn1_1(self.upconv1_1(x1de)),negative_slope=0.01)\n        print(x1de.size())\n        \n        return x1de","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:56.633643Z","iopub.execute_input":"2024-08-09T07:52:56.633932Z","iopub.status.idle":"2024-08-09T07:52:56.679198Z","shell.execute_reply.started":"2024-08-09T07:52:56.633907Z","shell.execute_reply":"2024-08-09T07:52:56.678364Z"},"trusted":true},"execution_count":29,"outputs":[]},{"cell_type":"code","source":"torch.manual_seed(44)\nPPN = pyramidnetwork()\nPPN_gpu = PPN.to(device1)","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:56.680277Z","iopub.execute_input":"2024-08-09T07:52:56.680588Z","iopub.status.idle":"2024-08-09T07:52:57.176565Z","shell.execute_reply.started":"2024-08-09T07:52:56.680563Z","shell.execute_reply":"2024-08-09T07:52:57.175788Z"},"trusted":true},"execution_count":30,"outputs":[]},{"cell_type":"code","source":"#BEV map creation for a sequence of scans(6 scans=1 sequence)\nfor i in range(15, 16):#6=len(files)\n    #load prev scans(5 scans as prev scans)\n    previous_scans = []\n    for j in range(i-15, i):\n        print(j)\n        pcd4d = extract_pcd(directory, files[j])\n        bevmap = convert_scan_bevmap(pcd4d, 0.2, 1000, device1)\n        # Plot the BEV map\n        #plt.imshow(bevmap.cpu(), cmap='hot')\n        #plt.show()\n        previous_scans.append(bevmap)\n    #load current scan\n    print(i,r\"(current)\")\n    pcd4d = extract_pcd(directory, files[i])\n    current_scan = convert_scan_bevmap(pcd4d, 0.2, 1000, device1)\n    # Plot the BEV map\n    #plt.imshow(current_scan.cpu(), cmap='hot')\n    #plt.show()\n    \n    #feed into PPN\n    ppn_pred_gpu = PPN_gpu(previous_scans,current_scan)\n    ppn_pred = ppn_pred_gpu.cpu().detach().numpy()\n    ppn_pred_pl = ppn_pred[0, 0, :, :]#batch=1,channel=1\n    #plot the image\n    plt.imshow(ppn_pred_pl, cmap='hot')\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:57.178666Z","iopub.execute_input":"2024-08-09T07:52:57.178978Z","iopub.status.idle":"2024-08-09T07:52:57.564275Z","shell.execute_reply.started":"2024-08-09T07:52:57.178951Z","shell.execute_reply":"2024-08-09T07:52:57.563367Z"},"trusted":true},"execution_count":31,"outputs":[{"name":"stdout","text":"0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15 (current)\ntorch.Size([1, 1, 1000, 1000])\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"\"\"\"#benchmarking\n# Hyperparameters\nlearning_rate = 0.0001\nbeta = 1  # Smooth L1 loss parameter\nlossfun1 = nn.SmoothL1Loss()\nlossfun2 = nn.MSELoss()\n# Optimizer\noptimizer = Adam(PPN_gpu.parameters(), lr=learning_rate)\ntraining_losses = []\nvalidation_losses = []\nfor e in range(0,1):\n    for i in range(15,700):\n        previous_scans=[]\n        for j in range(i-15,i):\n            pcd4d = extract_pcd(directory, files[j])\n            bevmap = convert_scan_bevmap(pcd4d,0.2,1000, device1)\n            previous_scans.append(bevmap)\n        pcd4d = extract_pcd(directory, files[i])\n        current_scan = convert_scan_bevmap(pcd4d, 0.2,1000, device1)\n        #feed into PPN\n        ppn_pred_gpu = PPN_gpu(previous_scans,current_scan)\n        #corresponding future training scene evolution\n        future_scans = []\n        for k in range(i+2,i+2+16):\n            futpcd = extract_pcd(directory, files[k])\n            futbev = convert_scan_bevmap(futpcd, 0.2, 1000, device1)\n            future_scans.append(futbev)\n        bevs_stack = torch.stack(future_scans)\n        bevs_stack = bevs_stack.float()\n        bevs_ten = bevs_stack.unsqueeze(0)\n        #feed into ground turth generator\n        loss = lossfun1(ppn_pred_gpu, bevs_ten) + lossfun2(ppn_pred_gpu, bevs_ten)\n        optimizer.zero_grad()\n        loss.backward()\n        optimizer.step()\n        training_losses.append(loss.item())\n        print(i,\"loss:\",loss)\n        # Validation loop\n        with torch.no_grad():  # Ensure no gradients are computed\n            for vi in range(5000+i, 5001+i):  # files for validation\n                vprevious_scans = []\n                for vj in range(vi - 15, vi):\n                    vpcd4d = extract_pcd(directory, files[vj])\n                    vbevmap = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\n                    vprevious_scans.append(vbevmap)\n                vpcd4d = extract_pcd(directory, files[vi])\n                vcurrent_scan = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\n                # Feed into PPN\n                ppn_v_gpu = PPN_gpu(vprevious_scans, vcurrent_scan)\n                # Corresponding future validation scene evolution\n                vfuture_scans = []\n                for vk in range(vi + 2, vi + 2 + 16):\n                    vfutpcd = extract_pcd(directory, files[vk])\n                    vfutbev = convert_scan_bevmap(vfutpcd, 0.2, 1000, device1)\n                    vfuture_scans.append(vfutbev)\n                vbevs_stack = torch.stack(vfuture_scans)\n                vbevs_stack = vbevs_stack.float()\n                vbevs_ten = vbevs_stack.unsqueeze(0)\n                # Calculate validation loss\n                vloss = lossfun1(ppn_v_gpu, vbevs_ten) + lossfun2(ppn_v_gpu, vbevs_ten)\n            validation_losses.append(vloss.item()) \n            print(vi,\"Validation loss:\", vloss)\n\n# Learning curve after training\nplt.plot(training_losses, label=\"Training Loss\", color='blue')\nplt.plot(validation_losses, label=\"Validation Loss\", color='orange')\nplt.xlabel(\"Iteration\")\nplt.ylabel(\"Loss\")\nplt.title(\"Learning Curve for benchmarking\")\nplt.legend()\nplt.show()\"\"\"","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:57.565865Z","iopub.execute_input":"2024-08-09T07:52:57.566223Z","iopub.status.idle":"2024-08-09T07:52:57.576257Z","shell.execute_reply.started":"2024-08-09T07:52:57.566191Z","shell.execute_reply":"2024-08-09T07:52:57.575454Z"},"trusted":true},"execution_count":32,"outputs":[{"execution_count":32,"output_type":"execute_result","data":{"text/plain":"'#benchmarking\\n# Hyperparameters\\nlearning_rate = 0.0001\\nbeta = 1  # Smooth L1 loss parameter\\nlossfun1 = nn.SmoothL1Loss()\\nlossfun2 = nn.MSELoss()\\n# Optimizer\\noptimizer = Adam(PPN_gpu.parameters(), lr=learning_rate)\\ntraining_losses = []\\nvalidation_losses = []\\nfor e in range(0,1):\\n    for i in range(15,700):\\n        previous_scans=[]\\n        for j in range(i-15,i):\\n            pcd4d = extract_pcd(directory, files[j])\\n            bevmap = convert_scan_bevmap(pcd4d,0.2,1000, device1)\\n            previous_scans.append(bevmap)\\n        pcd4d = extract_pcd(directory, files[i])\\n        current_scan = convert_scan_bevmap(pcd4d, 0.2,1000, device1)\\n        #feed into PPN\\n        ppn_pred_gpu = PPN_gpu(previous_scans,current_scan)\\n        #corresponding future training scene evolution\\n        future_scans = []\\n        for k in range(i+2,i+2+16):\\n            futpcd = extract_pcd(directory, files[k])\\n            futbev = convert_scan_bevmap(futpcd, 0.2, 1000, device1)\\n            future_scans.append(futbev)\\n        bevs_stack = torch.stack(future_scans)\\n        bevs_stack = bevs_stack.float()\\n        bevs_ten = bevs_stack.unsqueeze(0)\\n        #feed into ground turth generator\\n        loss = lossfun1(ppn_pred_gpu, bevs_ten) + lossfun2(ppn_pred_gpu, bevs_ten)\\n        optimizer.zero_grad()\\n        loss.backward()\\n        optimizer.step()\\n        training_losses.append(loss.item())\\n        print(i,\"loss:\",loss)\\n        # Validation loop\\n        with torch.no_grad():  # Ensure no gradients are computed\\n            for vi in range(5000+i, 5001+i):  # files for validation\\n                vprevious_scans = []\\n                for vj in range(vi - 15, vi):\\n                    vpcd4d = extract_pcd(directory, files[vj])\\n                    vbevmap = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\\n                    vprevious_scans.append(vbevmap)\\n                vpcd4d = extract_pcd(directory, files[vi])\\n                vcurrent_scan = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\\n                # Feed into PPN\\n                ppn_v_gpu = PPN_gpu(vprevious_scans, vcurrent_scan)\\n                # Corresponding future validation scene evolution\\n                vfuture_scans = []\\n                for vk in range(vi + 2, vi + 2 + 16):\\n                    vfutpcd = extract_pcd(directory, files[vk])\\n                    vfutbev = convert_scan_bevmap(vfutpcd, 0.2, 1000, device1)\\n                    vfuture_scans.append(vfutbev)\\n                vbevs_stack = torch.stack(vfuture_scans)\\n                vbevs_stack = vbevs_stack.float()\\n                vbevs_ten = vbevs_stack.unsqueeze(0)\\n                # Calculate validation loss\\n                vloss = lossfun1(ppn_v_gpu, vbevs_ten) + lossfun2(ppn_v_gpu, vbevs_ten)\\n            validation_losses.append(vloss.item()) \\n            print(vi,\"Validation loss:\", vloss)\\n\\n# Learning curve after training\\nplt.plot(training_losses, label=\"Training Loss\", color=\\'blue\\')\\nplt.plot(validation_losses, label=\"Validation Loss\", color=\\'orange\\')\\nplt.xlabel(\"Iteration\")\\nplt.ylabel(\"Loss\")\\nplt.title(\"Learning Curve for benchmarking\")\\nplt.legend()\\nplt.show()'"},"metadata":{}}]},{"cell_type":"code","source":"#scene prediction\nfor i in range(7000,7001):\n    previous_scans=[]\n    for j in range(i-15,i):\n        pcd4d = extract_pcd(directory, files[j])\n        bevmap = convert_scan_bevmap(pcd4d,0.2,1000,device1)\n        previous_scans.append(bevmap)\n    pcd4d = extract_pcd(directory, files[i])\n    current_scan = convert_scan_bevmap(pcd4d, 0.2,1000,device1)\n    plt.imshow(current_scan.cpu(), cmap='hot')\n    plt.show()\n    #feed into PPN\n    ppn_pred_gpu = PPN_gpu(previous_scans,current_scan)\n    future_np = ppn_pred_gpu.cpu().detach().numpy()\n    future_pl = future_np[0, 0, :, :]#batch=1,channel=1\n    #plot the image\n    plt.imshow(future_pl, cmap='hot')\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:57.577552Z","iopub.execute_input":"2024-08-09T07:52:57.577876Z","iopub.status.idle":"2024-08-09T07:52:58.174333Z","shell.execute_reply.started":"2024-08-09T07:52:57.577851Z","shell.execute_reply":"2024-08-09T07:52:58.173397Z"},"trusted":true},"execution_count":33,"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"name":"stdout","text":"torch.Size([1, 1, 1000, 1000])\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"#save trained model's parameters\ntorch.save(PPN_gpu.state_dict(), \"racetrained-PPN-segnet.pth\")","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:58.175594Z","iopub.execute_input":"2024-08-09T07:52:58.176009Z","iopub.status.idle":"2024-08-09T07:52:58.650368Z","shell.execute_reply.started":"2024-08-09T07:52:58.175972Z","shell.execute_reply":"2024-08-09T07:52:58.649360Z"},"trusted":true},"execution_count":34,"outputs":[]},{"cell_type":"code","source":"class autonetwork(nn.Module):\n    def __init__(self):\n        super(autonetwork, self).__init__()\n        ##### encoder\n        self.conv1 = nn.Conv2d(16,32,1,1)\n        self.bn1 = nn.BatchNorm2d(32)\n        self.conv1_1 = nn.Conv2d(32,32,3,1,1)\n        self.bn1_1 = nn.BatchNorm2d(32)\n        \n        self.conv2 = nn.Conv2d(32,64,3,1,1)\n        self.bn2 = nn.BatchNorm2d(64)\n        self.conv2_1 = nn.Conv2d(64,64,3,1,1)\n        self.bn2_1 = nn.BatchNorm2d(64)\n        \n        self.conv3 = nn.Conv2d(64,128,3,1,1)\n        self.bn3 = nn.BatchNorm2d(128)\n        self.conv3_1 = nn.Conv2d(128,128,3,1,1)\n        self.bn3_1 = nn.BatchNorm2d(128)\n        \n        self.conv4 = nn.Conv2d(128,256,3,1,1)\n        self.bn4 = nn.BatchNorm2d(256)\n        self.conv4_1 = nn.Conv2d(256,256,3,1,1)\n        self.bn4_1 = nn.BatchNorm2d(256)\n        \n        self.conv5 = nn.Conv2d(256,512,3,1,1)\n        self.bn5 = nn.BatchNorm2d(512)\n        self.conv5_1 = nn.Conv2d(512,512,3,1,1)\n        self.bn5_1 = nn.BatchNorm2d(512)\n        \n        self.conv6 = nn.Conv2d(512,1024,3,1,1)\n        self.bn6 = nn.BatchNorm2d(1024)\n        self.conv6_1 = nn.Conv2d(1024,1024,3,1,1)\n        self.bn6_1 = nn.BatchNorm2d(1024)\n        ##### decoder\n        self.tranconv6 = nn.ConvTranspose2d(1024,512,3,2)\n        self.tranbn6 = nn.BatchNorm2d(512)\n        self.upconv6_1 = nn.ConvTranspose2d(512,512,3,1,1)\n        self.upbn6_1 = nn.BatchNorm2d(512)\n        \n        self.tranconv5 = nn.ConvTranspose2d(512,256,2,2)\n        self.tranbn5 = nn.BatchNorm2d(256)\n        self.upconv5_1 = nn.ConvTranspose2d(256,256,3,1,1)\n        self.upbn5_1 = nn.BatchNorm2d(256)\n        \n        self.tranconv4 = nn.ConvTranspose2d(256,128,3,2)\n        self.tranbn4 = nn.BatchNorm2d(128)\n        self.upconv4_1 = nn.ConvTranspose2d(128,128,3,1,1)\n        self.upbn4_1 = nn.BatchNorm2d(128)\n        \n        self.tranconv3 = nn.ConvTranspose2d(128,64,2,2)\n        self.tranbn3 = nn.BatchNorm2d(64)\n        self.upconv3_1 = nn.ConvTranspose2d(64,64,3,1,1)\n        self.upbn3_1 = nn.BatchNorm2d(64)\n        \n        self.tranconv2 = nn.ConvTranspose2d(64,32,2,2)\n        self.tranbn2 = nn.BatchNorm2d(32)\n        self.upconv2_1 = nn.ConvTranspose2d(32,32,3,1,1)\n        self.upbn2_1 = nn.BatchNorm2d(32)\n        \n        self.tranconv1 = nn.ConvTranspose2d(32,16,2,2)\n        self.tranbn1 = nn.BatchNorm2d(16)\n        self.upconv1_1 = nn.ConvTranspose2d(16,1,3,1,1)\n        self.upbn1_1 = nn.BatchNorm2d(1)\n        \n        self.maxpool = nn.MaxPool2d(kernel_size=2,stride=2)\n    def forward(self, pastscans,currscan):\n        #stack scans\n        xbevs = pastscans + [currscan]\n        xbevs_stack = torch.stack(xbevs)\n        xbevs_stack = xbevs_stack.float()\n        xbevs_ten = xbevs_stack.unsqueeze(0)\n        #print(xbevs_ten.shape)\n        #encoding\n        x1 = F.leaky_relu(self.bn1(self.conv1(xbevs_ten)),negative_slope=0.01)\n        x1 = F.leaky_relu(self.bn1_1(self.conv1_1(x1)),negative_slope=0.01)\n        x1 = self.maxpool(x1)\n\n        x2 = F.leaky_relu(self.bn2(self.conv2(x1)),negative_slope=0.01)\n        x2 = F.leaky_relu(self.bn2_1(self.conv2_1(x2)),negative_slope=0.01)\n        x2 = self.maxpool(x2)\n\n        x3 = F.leaky_relu(self.bn3(self.conv3(x2)),negative_slope=0.01)\n        x3 = F.leaky_relu(self.bn3_1(self.conv3_1(x3)),negative_slope=0.01)\n        x3 = self.maxpool(x3)\n        \n        x4 = F.leaky_relu(self.bn4(self.conv4(x3)),negative_slope=0.01)\n        x4 = F.leaky_relu(self.bn4_1(self.conv4_1(x4)),negative_slope=0.01)\n        x4 = self.maxpool(x4)\n\n        x5 = F.leaky_relu(self.bn5(self.conv5(x4)),negative_slope=0.01)\n        x5 = F.leaky_relu(self.bn5_1(self.conv5_1(x5)),negative_slope=0.01)\n        x5 = self.maxpool(x5)\n        \n        x6 = F.leaky_relu(self.bn6(self.conv6(x5)),negative_slope=0.01)\n        x6 = F.leaky_relu(self.bn6_1(self.conv6_1(x6)),negative_slope=0.01)\n        x_6 = self.maxpool(x6)\n        #decoding\n        x6up = F.leaky_relu(self.tranbn6(self.tranconv6(x_6)),negative_slope=0.01)\n        x6up = F.leaky_relu(self.upbn6_1(self.upconv6_1(x6up)),negative_slope=0.01)\n\n        x5up = F.leaky_relu(self.tranbn5(self.tranconv5(x6up)),negative_slope=0.01)\n        x5up = F.leaky_relu(self.upbn5_1(self.upconv5_1(x5up)),negative_slope=0.01)\n    \n        x4up = F.leaky_relu(self.tranbn4(self.tranconv4(x5up)),negative_slope=0.01)\n        x4up = F.leaky_relu(self.upbn4_1(self.upconv4_1(x4up)),negative_slope=0.01)\n\n        x3up = F.leaky_relu(self.tranbn3(self.tranconv3(x4up)),negative_slope=0.01)\n        x3up = F.leaky_relu(self.upbn3_1(self.upconv3_1(x3up)),negative_slope=0.01)\n\n        x2up = F.leaky_relu(self.tranbn2(self.tranconv2(x3up)),negative_slope=0.01)\n        x2up = F.leaky_relu(self.upbn2_1(self.upconv2_1(x2up)),negative_slope=0.01)\n\n        x1up = F.leaky_relu(self.tranbn1(self.tranconv1(x2up)),negative_slope=0.01)\n        x1up = F.leaky_relu(self.upbn1_1(self.upconv1_1(x1up)),negative_slope=0.01)\n        print(x1up.shape)\n        \n        return x1up","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:58.652062Z","iopub.execute_input":"2024-08-09T07:52:58.652388Z","iopub.status.idle":"2024-08-09T07:52:58.683246Z","shell.execute_reply.started":"2024-08-09T07:52:58.652362Z","shell.execute_reply":"2024-08-09T07:52:58.682361Z"},"trusted":true},"execution_count":35,"outputs":[]},{"cell_type":"code","source":"torch.manual_seed(44)\naPPN = autonetwork()\naPPN_gpu = aPPN.to(device2)","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:58.684539Z","iopub.execute_input":"2024-08-09T07:52:58.684912Z","iopub.status.idle":"2024-08-09T07:52:58.973589Z","shell.execute_reply.started":"2024-08-09T07:52:58.684879Z","shell.execute_reply":"2024-08-09T07:52:58.972813Z"},"trusted":true},"execution_count":36,"outputs":[]},{"cell_type":"code","source":"#BEV map creation for a sequence of scans(6 scans=1 sequence)\nfor i in range(15, 16):#6=len(files)\n    #load prev scans(5 scans as prev scans)\n    previous_scans = []\n    for j in range(i-15, i):\n        print(j)\n        pcd4d = extract_pcd(directory, files[j])\n        bevmap = convert_scan_bevmap(pcd4d, 0.2, 1000, device2)\n        # Plot the BEV map\n        #plt.imshow(bevmap.cpu(), cmap='hot')\n        #plt.show()\n        previous_scans.append(bevmap)\n    #load current scan\n    print(i,r\"(current)\")\n    pcd4d = extract_pcd(directory, files[i])\n    current_scan = convert_scan_bevmap(pcd4d, 0.2, 1000, device2)\n    # Plot the BEV map\n    #plt.imshow(current_scan.cpu(), cmap='hot')\n    #plt.show()\n    \n    #feed into PPN\n    appn_pred_gpu = aPPN_gpu(previous_scans,current_scan)\n    appn_pred = appn_pred_gpu.cpu().detach().numpy()\n    appn_pred_pl = appn_pred[0, 0, :, :]#batch=1,channel=1\n    #plot the image\n    plt.imshow(appn_pred_pl, cmap='hot')\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:58.977170Z","iopub.execute_input":"2024-08-09T07:52:58.977873Z","iopub.status.idle":"2024-08-09T07:52:59.355989Z","shell.execute_reply.started":"2024-08-09T07:52:58.977838Z","shell.execute_reply":"2024-08-09T07:52:59.355060Z"},"trusted":true},"execution_count":37,"outputs":[{"name":"stdout","text":"0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15 (current)\ntorch.Size([1, 1, 1000, 1000])\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"import cv2\n#intersrction over union as loss\ndef IoU_loss(pred, target):\n    # Squeeze the batch dimension (if present)\n    pred = pred.squeeze(0)\n    target = target.squeeze(0)\n    # Intersection\n    intersection = torch.sum(pred * target)\n    #Using logical OR for efficient union calculation\n    union = torch.sum(torch.logical_or(pred, target)) - intersection\n    # IoU loss (add epsilon for stability)\n    iou = torch.div(intersection + 1e-6, union + 1e-6)\n    loss = 1 - iou\n    return loss.unsqueeze(0)\n#canny edge detector with mse + smoothl1 as loss function\ndef MSSCE(pred, truth, th1,th2, gpu, al=0.85):\n    pred = pred.float()\n    truth = truth.float()\n    prednp = pred.cpu().detach().numpy()\n    truthnp = truth.cpu().detach().numpy()\n    #canny edge detectors\n    pred_edgenp = np.array([cv2.Canny(i.astype(np.uint8), th1, th2) for i in prednp])\n    truth_edgenp = np.array([cv2.Canny(i.astype(np.uint8), th1, th2) for i in truthnp])\n    pred_edge = torch.from_numpy(pred_edgenp).float().to(gpu)\n    truth_edge = torch.from_numpy(truth_edgenp).float().to(gpu)\n    mse = lossfun2(pred,truth)\n    edgeloss = lossfun2(pred_edge, truth_edge)\n    sl1 = lossfun1(pred,truth)\n    sedgeloss = lossfun1(pred_edge, truth_edge)\n    #MSCE loss\n    msceloss = al*mse+(1-al)*edgeloss + al*sl1+(1-al)*sedgeloss\n    return msceloss","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:52:59.357270Z","iopub.execute_input":"2024-08-09T07:52:59.357601Z","iopub.status.idle":"2024-08-09T07:52:59.369367Z","shell.execute_reply.started":"2024-08-09T07:52:59.357574Z","shell.execute_reply":"2024-08-09T07:52:59.368466Z"},"trusted":true},"execution_count":38,"outputs":[]},{"cell_type":"code","source":"#training MSSCE\n# Hyperparameters\nlearning_rate = 0.001\nearly_stopping_threshold = 0.1\nbeta = 1  # Smooth L1 loss parameter\nlossfun1 = nn.SmoothL1Loss()\nlossfun2 = nn.MSELoss()\n# Optimizer\noptimizer = Adam(aPPN_gpu.parameters(), lr=learning_rate)\ntraining_losses = []\nvalidation_losses = []\nfor e in range(0,1):\n    for i in range(15,700):\n        previous_scans1=[]\n        previous_scans2=[]\n        for j in range(i-15,i):\n            pcd4d = extract_pcd(directory, files[j])\n            bevmap2 = convert_scan_bevmap(pcd4d,0.2,1000, device2)\n            bevmap1 = convert_scan_bevmap(pcd4d,0.2,1000, device1)\n            previous_scans2.append(bevmap2)\n            previous_scans1.append(bevmap1)\n        pcd4d = extract_pcd(directory, files[i])\n        current_scan2 = convert_scan_bevmap(pcd4d, 0.2,1000, device2)\n        current_scan1 = convert_scan_bevmap(pcd4d, 0.2,1000, device1)\n        #feed into aPPN\n        appn_pred_gpu = aPPN_gpu(previous_scans2,current_scan2)\n        #corresponding segmented training scene evolution\n        ppn_pred_gpu = PPN_gpu(previous_scans1,current_scan1)\n        ppn_pred_gpu2 = ppn_pred_gpu.to(device2)\n        #feed into loss function\n        loss = MSSCE(appn_pred_gpu, ppn_pred_gpu2,0,0,device2)\n        if loss.item() < early_stopping_threshold:\n            print(\"Early stopping: Loss reached threshold (\", loss.item(), \")\")\n            break\n        optimizer.zero_grad()\n        loss.backward()\n        optimizer.step()\n        training_losses.append(loss.item())\n        print(i,\"loss:\",loss)\n        # Validation loop\n        with torch.no_grad():  # Ensure no gradients are computed\n            for vi in range(5000+i, 5001+i):  # files for validation\n                vprevious_scans1 = []\n                vprevious_scans2 = []\n                for vj in range(vi - 15, vi):\n                    vpcd4d = extract_pcd(directory, files[vj])\n                    vbevmap2 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device2)\n                    vbevmap1 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\n                    vprevious_scans2.append(vbevmap2)\n                    vprevious_scans1.append(vbevmap1)\n                vpcd4d = extract_pcd(directory, files[vi])\n                vcurrent_scan2 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device2)\n                vcurrent_scan1 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\n                # Feed into aPPN\n                appn_v_gpu = aPPN_gpu(vprevious_scans2, vcurrent_scan2)\n                #corresponding segmented training scene evolution\n                ppn_v_gpu = PPN_gpu(vprevious_scans1,vcurrent_scan1)\n                ppn_v_gpu2 = ppn_v_gpu.to(device2)\n                # Calculate validation loss\n                vloss = MSSCE(appn_v_gpu, ppn_v_gpu2,0,0,device2)\n            validation_losses.append(vloss.item()) \n            print(vi,\"Validation loss:\", vloss)\n# learning curve after training\nimport matplotlib.pyplot as plt\nplt.plot(training_losses, label=\"Training Loss\", color='blue')\nplt.plot(validation_losses, label=\"Validation Loss\", color='orange')\nplt.xlabel(\"Training Iteration\")\nplt.ylabel(f\"MSSCE Loss \")\nplt.title(\"Learning Curve for Scene Evolution\")\nplt.legend()\nplt.show()","metadata":{"_kg_hide-output":false,"execution":{"iopub.status.busy":"2024-08-09T07:52:59.370570Z","iopub.execute_input":"2024-08-09T07:52:59.370846Z","iopub.status.idle":"2024-08-09T07:57:48.499508Z","shell.execute_reply.started":"2024-08-09T07:52:59.370822Z","shell.execute_reply":"2024-08-09T07:57:48.498475Z"},"trusted":true},"execution_count":39,"outputs":[{"name":"stdout","text":"torch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n15 loss: tensor(510.2032, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5015 Validation loss: tensor(79.1259, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n16 loss: tensor(216.1907, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5016 Validation loss: tensor(108.3970, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n17 loss: tensor(127.9671, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5017 Validation loss: tensor(196.4990, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n18 loss: tensor(196.4933, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5018 Validation loss: tensor(127.9328, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n19 loss: tensor(147.4927, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5019 Validation loss: tensor(108.3307, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n20 loss: tensor(186.6415, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5020 Validation loss: tensor(127.9127, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n21 loss: tensor(274.7632, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5021 Validation loss: tensor(98.5406, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n22 loss: tensor(274.7546, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5022 Validation loss: tensor(108.3327, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n23 loss: tensor(362.8718, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5023 Validation loss: tensor(147.5029, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n24 loss: tensor(284.5398, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5024 Validation loss: tensor(59.3725, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n25 loss: tensor(304.1257, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5025 Validation loss: tensor(137.7149, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n26 loss: tensor(225.7878, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5026 Validation loss: tensor(69.1702, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n27 loss: tensor(284.5252, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5027 Validation loss: tensor(176.8662, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n28 loss: tensor(362.8662, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5028 Validation loss: tensor(147.4985, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n29 loss: tensor(353.0681, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5029 Validation loss: tensor(118.1262, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n30 loss: tensor(274.7302, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5030 Validation loss: tensor(137.6995, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n31 loss: tensor(343.2755, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5031 Validation loss: tensor(137.6871, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n32 loss: tensor(284.5131, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5032 Validation loss: tensor(157.2717, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n33 loss: tensor(176.7971, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5033 Validation loss: tensor(167.0658, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n34 loss: tensor(274.7137, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5034 Validation loss: tensor(206.2321, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n35 loss: tensor(215.9532, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5035 Validation loss: tensor(137.6985, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n36 loss: tensor(235.5563, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5036 Validation loss: tensor(78.9339, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n37 loss: tensor(264.9191, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5037 Validation loss: tensor(69.1360, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n38 loss: tensor(274.7068, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5038 Validation loss: tensor(186.6387, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n39 loss: tensor(225.7540, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5039 Validation loss: tensor(118.0988, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n40 loss: tensor(353.0428, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5040 Validation loss: tensor(186.6486, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n41 loss: tensor(304.0870, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5041 Validation loss: tensor(216.0248, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n42 loss: tensor(372.6225, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5042 Validation loss: tensor(127.9039, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n43 loss: tensor(343.2485, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5043 Validation loss: tensor(167.0706, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n44 loss: tensor(264.9074, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5044 Validation loss: tensor(88.7367, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n45 loss: tensor(323.6637, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5045 Validation loss: tensor(264.9909, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n46 loss: tensor(343.2515, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5046 Validation loss: tensor(108.3262, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n47 loss: tensor(323.6578, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5047 Validation loss: tensor(167.0781, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n48 loss: tensor(353.0309, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5048 Validation loss: tensor(157.2818, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n49 loss: tensor(176.7817, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5049 Validation loss: tensor(176.8611, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n50 loss: tensor(137.6231, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5050 Validation loss: tensor(127.9052, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n51 loss: tensor(362.8195, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5051 Validation loss: tensor(127.9110, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n52 loss: tensor(313.8685, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5052 Validation loss: tensor(98.5528, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n53 loss: tensor(284.4892, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5053 Validation loss: tensor(137.7088, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n54 loss: tensor(441.1723, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5054 Validation loss: tensor(167.0861, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n55 loss: tensor(343.2354, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5055 Validation loss: tensor(118.1257, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n56 loss: tensor(372.6163, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5056 Validation loss: tensor(157.2812, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n57 loss: tensor(333.4388, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5057 Validation loss: tensor(137.6995, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n58 loss: tensor(372.6099, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5058 Validation loss: tensor(137.7042, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n59 loss: tensor(382.4037, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5059 Validation loss: tensor(108.3255, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n60 loss: tensor(372.6097, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5060 Validation loss: tensor(176.8728, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n61 loss: tensor(372.6049, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5061 Validation loss: tensor(206.2411, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n62 loss: tensor(450.9330, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5062 Validation loss: tensor(186.6692, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n63 loss: tensor(225.7251, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5063 Validation loss: tensor(69.1657, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n64 loss: tensor(372.5965, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5064 Validation loss: tensor(147.4931, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n65 loss: tensor(264.8794, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5065 Validation loss: tensor(147.4924, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n66 loss: tensor(274.6802, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5066 Validation loss: tensor(137.6834, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n67 loss: tensor(323.6328, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5067 Validation loss: tensor(137.6839, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n68 loss: tensor(343.2240, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5068 Validation loss: tensor(108.3076, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n69 loss: tensor(215.9258, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5069 Validation loss: tensor(98.5239, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n70 loss: tensor(196.3369, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5070 Validation loss: tensor(88.7284, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n71 loss: tensor(352.9932, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5071 Validation loss: tensor(157.2658, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n72 loss: tensor(294.2608, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5072 Validation loss: tensor(157.2524, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n73 loss: tensor(304.0391, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5073 Validation loss: tensor(108.3051, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n74 loss: tensor(206.1151, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5074 Validation loss: tensor(88.7188, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n75 loss: tensor(323.6122, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5075 Validation loss: tensor(157.2464, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n76 loss: tensor(401.9559, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5076 Validation loss: tensor(98.5124, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n77 loss: tensor(313.8255, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5077 Validation loss: tensor(118.1004, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n78 loss: tensor(323.6163, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5078 Validation loss: tensor(69.1136, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n79 loss: tensor(274.6572, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5079 Validation loss: tensor(108.2794, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n80 loss: tensor(343.2087, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5080 Validation loss: tensor(98.4964, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n81 loss: tensor(431.3300, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5081 Validation loss: tensor(69.1316, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n82 loss: tensor(421.5290, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5082 Validation loss: tensor(69.1273, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n83 loss: tensor(323.6025, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5083 Validation loss: tensor(127.8600, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n84 loss: tensor(225.6847, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5084 Validation loss: tensor(98.4642, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n85 loss: tensor(421.5326, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5085 Validation loss: tensor(88.6782, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n86 loss: tensor(490.0584, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5086 Validation loss: tensor(127.8468, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n87 loss: tensor(264.8578, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5087 Validation loss: tensor(176.8134, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n88 loss: tensor(343.1907, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5088 Validation loss: tensor(98.4620, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n89 loss: tensor(343.1849, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5089 Validation loss: tensor(108.2530, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n90 loss: tensor(255.0795, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5090 Validation loss: tensor(49.5109, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n91 loss: tensor(274.6368, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5091 Validation loss: tensor(147.4218, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n92 loss: tensor(245.2735, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5092 Validation loss: tensor(118.0460, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n93 loss: tensor(245.2674, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5093 Validation loss: tensor(166.9937, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n94 loss: tensor(352.9768, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5094 Validation loss: tensor(137.6211, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n95 loss: tensor(245.2696, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5095 Validation loss: tensor(137.6214, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n96 loss: tensor(245.2640, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5096 Validation loss: tensor(206.1575, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n97 loss: tensor(117.9677, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5097 Validation loss: tensor(127.8290, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n98 loss: tensor(235.4626, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5098 Validation loss: tensor(157.1887, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n99 loss: tensor(186.5176, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5099 Validation loss: tensor(176.7789, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n100 loss: tensor(294.2293, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5100 Validation loss: tensor(127.8102, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n101 loss: tensor(186.5085, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5101 Validation loss: tensor(147.3967, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n102 loss: tensor(166.9293, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5102 Validation loss: tensor(166.9796, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n103 loss: tensor(215.8846, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5103 Validation loss: tensor(137.6044, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n104 loss: tensor(176.7329, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5104 Validation loss: tensor(215.9268, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n105 loss: tensor(206.0941, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5105 Validation loss: tensor(176.7700, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n106 loss: tensor(196.3140, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5106 Validation loss: tensor(78.8507, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n107 loss: tensor(255.0560, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5107 Validation loss: tensor(98.4240, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n108 loss: tensor(206.1048, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5108 Validation loss: tensor(137.5956, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n109 loss: tensor(127.7619, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5109 Validation loss: tensor(157.1666, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n110 loss: tensor(176.7366, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5110 Validation loss: tensor(88.6239, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n111 loss: tensor(157.1372, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5111 Validation loss: tensor(147.3801, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n112 loss: tensor(274.6453, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5112 Validation loss: tensor(137.5866, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n113 loss: tensor(137.5615, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5113 Validation loss: tensor(88.6291, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n114 loss: tensor(166.9290, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5114 Validation loss: tensor(98.4164, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n115 loss: tensor(196.3062, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5115 Validation loss: tensor(215.9196, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n116 loss: tensor(235.4748, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5116 Validation loss: tensor(186.5321, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n117 loss: tensor(196.3031, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5117 Validation loss: tensor(117.9929, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n118 loss: tensor(108.1784, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5118 Validation loss: tensor(127.7761, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n119 loss: tensor(176.7304, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5119 Validation loss: tensor(147.3661, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n120 loss: tensor(166.9242, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5120 Validation loss: tensor(147.3689, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n121 loss: tensor(117.9671, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5121 Validation loss: tensor(215.9057, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n122 loss: tensor(108.1948, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5122 Validation loss: tensor(166.9489, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n123 loss: tensor(225.7032, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5123 Validation loss: tensor(117.9737, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n124 loss: tensor(137.5638, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5124 Validation loss: tensor(49.4458, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n125 loss: tensor(117.9675, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5125 Validation loss: tensor(127.7775, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n126 loss: tensor(108.1890, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5126 Validation loss: tensor(147.3657, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n127 loss: tensor(127.7665, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5127 Validation loss: tensor(157.1603, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n128 loss: tensor(108.1843, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5128 Validation loss: tensor(186.5383, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n129 loss: tensor(108.1808, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5129 Validation loss: tensor(166.9465, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n130 loss: tensor(69.0197, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5130 Validation loss: tensor(157.1688, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n131 loss: tensor(137.5530, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5131 Validation loss: tensor(117.9927, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n132 loss: tensor(117.9711, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5132 Validation loss: tensor(137.5690, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n133 loss: tensor(137.5563, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5133 Validation loss: tensor(127.7850, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n134 loss: tensor(98.3817, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5134 Validation loss: tensor(29.8577, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n135 loss: tensor(59.2261, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5135 Validation loss: tensor(117.9861, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n136 loss: tensor(49.4200, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5136 Validation loss: tensor(69.0329, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n137 loss: tensor(127.7646, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5137 Validation loss: tensor(59.2322, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n138 loss: tensor(39.6224, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5138 Validation loss: tensor(59.2318, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n139 loss: tensor(127.7647, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5139 Validation loss: tensor(39.6595, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n140 loss: tensor(78.8062, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5140 Validation loss: tensor(29.8620, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n141 loss: tensor(108.1751, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5141 Validation loss: tensor(39.6528, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n142 loss: tensor(78.8029, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5142 Validation loss: tensor(78.8226, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n143 loss: tensor(127.7493, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5143 Validation loss: tensor(49.4484, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n144 loss: tensor(98.3801, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5144 Validation loss: tensor(59.2361, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n145 loss: tensor(49.4114, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5145 Validation loss: tensor(78.8185, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n146 loss: tensor(68.9966, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5146 Validation loss: tensor(49.4498, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n147 loss: tensor(137.5471, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5147 Validation loss: tensor(88.6143, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n148 loss: tensor(68.9849, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5148 Validation loss: tensor(78.8173, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n149 loss: tensor(69.0016, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5149 Validation loss: tensor(98.4176, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n150 loss: tensor(88.5898, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5150 Validation loss: tensor(88.6091, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n151 loss: tensor(88.5828, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5151 Validation loss: tensor(88.6173, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n152 loss: tensor(117.9431, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5152 Validation loss: tensor(108.2015, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n153 loss: tensor(98.3567, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5153 Validation loss: tensor(59.2305, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n154 loss: tensor(78.7829, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5154 Validation loss: tensor(78.8285, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n155 loss: tensor(127.7292, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5155 Validation loss: tensor(88.6039, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n156 loss: tensor(78.7789, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5156 Validation loss: tensor(98.3973, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n157 loss: tensor(117.9528, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5157 Validation loss: tensor(59.2269, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n158 loss: tensor(108.1614, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5158 Validation loss: tensor(78.8173, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n159 loss: tensor(108.1482, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5159 Validation loss: tensor(49.4393, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n160 loss: tensor(88.5687, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5160 Validation loss: tensor(20.0691, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n161 loss: tensor(137.5304, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5161 Validation loss: tensor(29.8475, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n162 loss: tensor(98.3620, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5162 Validation loss: tensor(49.4386, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n163 loss: tensor(68.9851, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5163 Validation loss: tensor(59.2273, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n164 loss: tensor(98.3602, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5164 Validation loss: tensor(59.2302, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n165 loss: tensor(78.7780, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5165 Validation loss: tensor(59.2410, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n166 loss: tensor(98.3659, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5166 Validation loss: tensor(59.2448, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n167 loss: tensor(108.1538, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5167 Validation loss: tensor(69.0362, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n168 loss: tensor(108.1547, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5168 Validation loss: tensor(78.8220, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n169 loss: tensor(108.1588, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5169 Validation loss: tensor(59.2403, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n170 loss: tensor(78.7719, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5170 Validation loss: tensor(39.6628, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n171 loss: tensor(108.1511, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5171 Validation loss: tensor(127.7733, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n172 loss: tensor(108.1550, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5172 Validation loss: tensor(88.6140, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n173 loss: tensor(78.7752, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5173 Validation loss: tensor(137.5698, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n174 loss: tensor(59.2002, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5174 Validation loss: tensor(108.1843, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n175 loss: tensor(69.0018, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5175 Validation loss: tensor(69.0366, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n176 loss: tensor(68.9823, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5176 Validation loss: tensor(78.8271, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n177 loss: tensor(39.6233, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5177 Validation loss: tensor(69.0291, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n178 loss: tensor(98.3631, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5178 Validation loss: tensor(118.0130, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n179 loss: tensor(78.7890, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5179 Validation loss: tensor(69.0256, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n180 loss: tensor(98.3629, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5180 Validation loss: tensor(78.8290, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n181 loss: tensor(39.6065, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5181 Validation loss: tensor(78.8367, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n182 loss: tensor(59.1991, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5182 Validation loss: tensor(88.6154, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n183 loss: tensor(39.6099, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5183 Validation loss: tensor(88.6234, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n184 loss: tensor(59.1976, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5184 Validation loss: tensor(88.6170, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n185 loss: tensor(98.3625, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5185 Validation loss: tensor(98.3949, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n186 loss: tensor(108.1576, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5186 Validation loss: tensor(108.1872, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n187 loss: tensor(88.5660, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5187 Validation loss: tensor(88.6136, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n188 loss: tensor(49.4039, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5188 Validation loss: tensor(98.4093, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n189 loss: tensor(108.1502, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5189 Validation loss: tensor(88.6090, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n190 loss: tensor(127.7383, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5190 Validation loss: tensor(137.5743, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n191 loss: tensor(127.7358, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5191 Validation loss: tensor(127.7917, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n192 loss: tensor(78.7736, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5192 Validation loss: tensor(127.7810, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n193 loss: tensor(78.7796, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5193 Validation loss: tensor(118.0075, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n194 loss: tensor(108.1529, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5194 Validation loss: tensor(39.6726, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n195 loss: tensor(186.4922, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5195 Validation loss: tensor(59.2401, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n196 loss: tensor(98.3571, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5196 Validation loss: tensor(78.8228, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n197 loss: tensor(176.6869, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5197 Validation loss: tensor(39.6657, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n198 loss: tensor(98.3633, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5198 Validation loss: tensor(20.0767, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n199 loss: tensor(117.9457, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5199 Validation loss: tensor(39.6719, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n200 loss: tensor(88.5698, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5200 Validation loss: tensor(20.0879, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n201 loss: tensor(59.1920, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5201 Validation loss: tensor(20.0886, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n202 loss: tensor(68.9862, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5202 Validation loss: tensor(0.5167, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n203 loss: tensor(127.7388, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5203 Validation loss: tensor(0.5223, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n204 loss: tensor(98.3628, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5204 Validation loss: tensor(0.5166, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n205 loss: tensor(108.1536, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5205 Validation loss: tensor(0.5156, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n206 loss: tensor(127.7377, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5206 Validation loss: tensor(0.5124, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n207 loss: tensor(166.9031, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5207 Validation loss: tensor(0.5142, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n208 loss: tensor(166.9054, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5208 Validation loss: tensor(0.5129, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n209 loss: tensor(157.1097, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5209 Validation loss: tensor(0.5203, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n210 loss: tensor(235.4374, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5210 Validation loss: tensor(0.5196, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n211 loss: tensor(225.6499, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5211 Validation loss: tensor(0.5284, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n212 loss: tensor(117.9378, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5212 Validation loss: tensor(0.5241, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n213 loss: tensor(157.1005, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5213 Validation loss: tensor(0.5193, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n214 loss: tensor(284.4024, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5214 Validation loss: tensor(0.5280, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n215 loss: tensor(245.2388, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5215 Validation loss: tensor(0.5291, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n216 loss: tensor(206.0677, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5216 Validation loss: tensor(0.5308, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n217 loss: tensor(255.0353, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5217 Validation loss: tensor(0.5228, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n218 loss: tensor(176.6907, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5218 Validation loss: tensor(0.5280, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n219 loss: tensor(382.3179, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5219 Validation loss: tensor(0.5267, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n220 loss: tensor(362.7446, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5220 Validation loss: tensor(0.5176, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n221 loss: tensor(157.1065, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5221 Validation loss: tensor(0.5271, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n222 loss: tensor(196.2712, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5222 Validation loss: tensor(0.5083, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n223 loss: tensor(284.4090, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5223 Validation loss: tensor(20.1020, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n224 loss: tensor(284.4168, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5224 Validation loss: tensor(10.3120, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n225 loss: tensor(313.7812, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5225 Validation loss: tensor(20.1136, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n226 loss: tensor(382.3286, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5226 Validation loss: tensor(20.1060, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n227 loss: tensor(157.1187, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5227 Validation loss: tensor(39.6943, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n228 loss: tensor(206.0766, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5228 Validation loss: tensor(20.0949, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n229 loss: tensor(343.1586, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5229 Validation loss: tensor(59.2563, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n230 loss: tensor(284.4158, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5230 Validation loss: tensor(0.5180, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n231 loss: tensor(196.2876, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5231 Validation loss: tensor(59.2557, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n232 loss: tensor(245.2521, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5232 Validation loss: tensor(108.2139, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n233 loss: tensor(255.0443, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5233 Validation loss: tensor(98.4243, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n234 loss: tensor(147.3358, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5234 Validation loss: tensor(108.2312, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n235 loss: tensor(166.9150, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5235 Validation loss: tensor(39.6851, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n236 loss: tensor(225.6727, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5236 Validation loss: tensor(88.6415, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n237 loss: tensor(147.3405, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5237 Validation loss: tensor(59.2609, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n238 loss: tensor(98.3807, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5238 Validation loss: tensor(88.6552, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n239 loss: tensor(127.7565, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5239 Validation loss: tensor(49.4689, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n240 loss: tensor(88.5920, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5240 Validation loss: tensor(20.0878, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n241 loss: tensor(108.1724, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5241 Validation loss: tensor(39.6678, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n242 loss: tensor(59.2030, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5242 Validation loss: tensor(39.6867, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n243 loss: tensor(49.4149, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5243 Validation loss: tensor(20.0875, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n244 loss: tensor(88.5822, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5244 Validation loss: tensor(20.0877, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n245 loss: tensor(69.0006, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5245 Validation loss: tensor(39.6691, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n246 loss: tensor(49.4129, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5246 Validation loss: tensor(59.2484, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n247 loss: tensor(88.5903, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5247 Validation loss: tensor(59.2463, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n248 loss: tensor(88.5844, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5248 Validation loss: tensor(108.2152, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n249 loss: tensor(78.7935, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5249 Validation loss: tensor(98.4216, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n250 loss: tensor(108.1830, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5250 Validation loss: tensor(108.1996, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n251 loss: tensor(78.7900, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5251 Validation loss: tensor(69.0335, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n252 loss: tensor(69.0094, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5252 Validation loss: tensor(166.9626, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n253 loss: tensor(59.2072, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5253 Validation loss: tensor(127.7916, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n254 loss: tensor(88.5882, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5254 Validation loss: tensor(117.9925, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n255 loss: tensor(98.3705, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5255 Validation loss: tensor(49.4533, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n256 loss: tensor(68.9993, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5256 Validation loss: tensor(137.5922, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n257 loss: tensor(68.9952, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5257 Validation loss: tensor(147.3903, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n258 loss: tensor(157.1301, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5258 Validation loss: tensor(157.1862, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n259 loss: tensor(117.9558, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5259 Validation loss: tensor(59.2726, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n260 loss: tensor(88.5739, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5260 Validation loss: tensor(176.7587, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n261 loss: tensor(147.3311, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5261 Validation loss: tensor(118.0533, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n262 loss: tensor(137.5434, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5262 Validation loss: tensor(127.8099, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n263 loss: tensor(117.9409, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5263 Validation loss: tensor(108.2162, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n264 loss: tensor(127.7350, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5264 Validation loss: tensor(98.4560, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n265 loss: tensor(137.5399, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5265 Validation loss: tensor(108.2139, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n266 loss: tensor(137.5253, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5266 Validation loss: tensor(108.2231, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n267 loss: tensor(117.9604, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5267 Validation loss: tensor(98.4338, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n268 loss: tensor(127.7389, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5268 Validation loss: tensor(157.1954, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n269 loss: tensor(137.5308, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5269 Validation loss: tensor(127.8027, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n270 loss: tensor(157.1223, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5270 Validation loss: tensor(118.0168, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n271 loss: tensor(127.7353, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5271 Validation loss: tensor(108.2330, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n272 loss: tensor(147.3374, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5272 Validation loss: tensor(166.9772, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n273 loss: tensor(98.3601, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5273 Validation loss: tensor(157.1917, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n274 loss: tensor(235.4498, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5274 Validation loss: tensor(245.3198, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n275 loss: tensor(186.4847, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5275 Validation loss: tensor(255.1026, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n276 loss: tensor(137.5299, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5276 Validation loss: tensor(343.2190, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n277 loss: tensor(117.9484, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5277 Validation loss: tensor(284.4683, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n278 loss: tensor(235.4378, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5278 Validation loss: tensor(255.1069, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n279 loss: tensor(88.5627, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5279 Validation loss: tensor(255.1113, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n280 loss: tensor(196.2700, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5280 Validation loss: tensor(509.6944, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n281 loss: tensor(166.8920, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5281 Validation loss: tensor(284.4796, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n282 loss: tensor(186.4766, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5282 Validation loss: tensor(333.4309, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n283 loss: tensor(235.4408, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5283 Validation loss: tensor(255.1013, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n284 loss: tensor(176.6862, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5284 Validation loss: tensor(284.4885, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n285 loss: tensor(206.0592, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5285 Validation loss: tensor(401.9953, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n286 loss: tensor(176.6873, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5286 Validation loss: tensor(343.2251, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n287 loss: tensor(117.9278, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5287 Validation loss: tensor(450.9476, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n288 loss: tensor(176.6908, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5288 Validation loss: tensor(343.2400, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n289 loss: tensor(166.8977, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5289 Validation loss: tensor(353.0211, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n290 loss: tensor(186.4849, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5290 Validation loss: tensor(362.8042, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n291 loss: tensor(215.8452, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5291 Validation loss: tensor(411.7624, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n292 loss: tensor(166.8793, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5292 Validation loss: tensor(304.0562, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n293 loss: tensor(166.8830, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5293 Validation loss: tensor(186.5481, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n294 loss: tensor(186.4699, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5294 Validation loss: tensor(421.5596, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n295 loss: tensor(147.3039, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5295 Validation loss: tensor(323.6424, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n296 loss: tensor(78.7581, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5296 Validation loss: tensor(441.1435, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n297 loss: tensor(137.5131, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5297 Validation loss: tensor(382.3892, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n298 loss: tensor(108.1292, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5298 Validation loss: tensor(255.0971, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n299 loss: tensor(127.7162, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5299 Validation loss: tensor(480.3117, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n300 loss: tensor(98.3391, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5300 Validation loss: tensor(362.8007, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n301 loss: tensor(157.0899, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5301 Validation loss: tensor(490.0960, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n302 loss: tensor(98.3466, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5302 Validation loss: tensor(441.1337, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n303 loss: tensor(166.8906, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5303 Validation loss: tensor(382.3971, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n304 loss: tensor(78.7570, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5304 Validation loss: tensor(392.1740, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n305 loss: tensor(98.3453, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5305 Validation loss: tensor(401.9633, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n306 loss: tensor(29.7940, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5306 Validation loss: tensor(480.2958, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n307 loss: tensor(49.3800, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5307 Validation loss: tensor(392.1643, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n308 loss: tensor(98.3534, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5308 Validation loss: tensor(401.9718, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n309 loss: tensor(98.3438, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5309 Validation loss: tensor(343.2077, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n310 loss: tensor(157.0916, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5310 Validation loss: tensor(264.8891, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n311 loss: tensor(29.7906, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5311 Validation loss: tensor(382.4053, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n312 loss: tensor(108.1296, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5312 Validation loss: tensor(196.3335, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n313 loss: tensor(88.5489, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5313 Validation loss: tensor(343.2271, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n314 loss: tensor(157.0970, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5314 Validation loss: tensor(176.7536, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n315 loss: tensor(78.7562, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5315 Validation loss: tensor(245.3079, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n316 loss: tensor(68.9601, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5316 Validation loss: tensor(186.5749, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n317 loss: tensor(108.1466, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5317 Validation loss: tensor(264.9034, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n318 loss: tensor(117.9177, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5318 Validation loss: tensor(206.1562, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n319 loss: tensor(127.7182, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5319 Validation loss: tensor(167.0043, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n320 loss: tensor(127.7189, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5320 Validation loss: tensor(255.1309, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n321 loss: tensor(166.8849, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5321 Validation loss: tensor(215.9617, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n322 loss: tensor(147.3050, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5322 Validation loss: tensor(245.3183, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n323 loss: tensor(166.8813, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5323 Validation loss: tensor(206.1633, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n324 loss: tensor(88.5447, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5324 Validation loss: tensor(245.3310, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n325 loss: tensor(78.7538, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5325 Validation loss: tensor(255.1289, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n326 loss: tensor(147.2982, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5326 Validation loss: tensor(333.4695, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n327 loss: tensor(166.8744, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5327 Validation loss: tensor(284.5120, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n328 loss: tensor(206.0508, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5328 Validation loss: tensor(235.5286, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n329 loss: tensor(117.9197, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5329 Validation loss: tensor(157.2187, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n330 loss: tensor(176.6625, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5330 Validation loss: tensor(157.2155, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n331 loss: tensor(255.0102, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5331 Validation loss: tensor(147.4030, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n332 loss: tensor(108.1230, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5332 Validation loss: tensor(186.5902, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n333 loss: tensor(137.4980, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5333 Validation loss: tensor(157.2194, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n334 loss: tensor(206.0448, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5334 Validation loss: tensor(304.0738, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n335 loss: tensor(255.0056, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5335 Validation loss: tensor(157.2028, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n336 loss: tensor(215.8380, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5336 Validation loss: tensor(127.8503, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n337 loss: tensor(147.2920, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5337 Validation loss: tensor(118.0600, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n338 loss: tensor(196.2479, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5338 Validation loss: tensor(167.0277, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n339 loss: tensor(186.4626, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5339 Validation loss: tensor(98.4746, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n340 loss: tensor(176.6628, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5340 Validation loss: tensor(88.6638, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n341 loss: tensor(98.3313, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5341 Validation loss: tensor(196.3994, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n342 loss: tensor(196.2562, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5342 Validation loss: tensor(137.6354, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n343 loss: tensor(206.0435, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5343 Validation loss: tensor(98.4787, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n344 loss: tensor(117.9186, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5344 Validation loss: tensor(118.0450, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n345 loss: tensor(157.0820, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5345 Validation loss: tensor(137.6202, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n346 loss: tensor(137.4967, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5346 Validation loss: tensor(108.2589, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n347 loss: tensor(117.9186, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5347 Validation loss: tensor(167.0186, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n348 loss: tensor(68.9539, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5348 Validation loss: tensor(137.6749, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n349 loss: tensor(108.1299, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5349 Validation loss: tensor(137.6412, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n350 loss: tensor(137.5009, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5350 Validation loss: tensor(167.0148, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n351 loss: tensor(98.3262, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5351 Validation loss: tensor(98.4580, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n352 loss: tensor(127.7104, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5352 Validation loss: tensor(147.4159, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n353 loss: tensor(59.1624, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5353 Validation loss: tensor(118.0465, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n354 loss: tensor(19.9988, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5354 Validation loss: tensor(167.0204, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n355 loss: tensor(98.3358, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5355 Validation loss: tensor(137.6290, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n356 loss: tensor(78.7491, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5356 Validation loss: tensor(98.4568, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n357 loss: tensor(108.1297, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5357 Validation loss: tensor(98.4653, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n358 loss: tensor(108.1397, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5358 Validation loss: tensor(127.8246, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n359 loss: tensor(137.5035, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5359 Validation loss: tensor(78.8677, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n360 loss: tensor(157.0908, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5360 Validation loss: tensor(127.8156, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n361 loss: tensor(166.8834, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5361 Validation loss: tensor(69.0741, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n362 loss: tensor(127.7172, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5362 Validation loss: tensor(59.2737, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n363 loss: tensor(88.5489, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5363 Validation loss: tensor(118.0309, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n364 loss: tensor(137.5128, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5364 Validation loss: tensor(127.7995, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n365 loss: tensor(215.8404, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5365 Validation loss: tensor(20.0964, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n366 loss: tensor(186.4613, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5366 Validation loss: tensor(69.0447, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n367 loss: tensor(166.8854, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5367 Validation loss: tensor(108.2156, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n368 loss: tensor(166.8872, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5368 Validation loss: tensor(98.4305, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n369 loss: tensor(88.5435, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5369 Validation loss: tensor(59.2773, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n370 loss: tensor(264.8116, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5370 Validation loss: tensor(118.0239, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n371 loss: tensor(206.0525, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5371 Validation loss: tensor(78.8540, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n372 loss: tensor(147.2967, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5372 Validation loss: tensor(88.6457, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n373 loss: tensor(186.4679, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5373 Validation loss: tensor(78.8438, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n374 loss: tensor(235.4323, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5374 Validation loss: tensor(59.2618, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n375 loss: tensor(245.2153, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5375 Validation loss: tensor(69.0592, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n376 loss: tensor(235.4300, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5376 Validation loss: tensor(69.0728, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n377 loss: tensor(176.6673, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5377 Validation loss: tensor(78.8642, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n378 loss: tensor(176.6777, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5378 Validation loss: tensor(59.2682, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n379 loss: tensor(98.3385, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5379 Validation loss: tensor(39.6781, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n380 loss: tensor(186.4741, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5380 Validation loss: tensor(108.2301, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n381 loss: tensor(108.1320, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5381 Validation loss: tensor(118.0221, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n382 loss: tensor(255.0055, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5382 Validation loss: tensor(108.2504, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n383 loss: tensor(176.6704, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5383 Validation loss: tensor(127.8074, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n384 loss: tensor(147.3008, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5384 Validation loss: tensor(78.8619, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n385 loss: tensor(127.7069, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5385 Validation loss: tensor(78.8612, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n386 loss: tensor(245.2123, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5386 Validation loss: tensor(39.6810, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n387 loss: tensor(206.0488, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5387 Validation loss: tensor(78.8562, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n388 loss: tensor(255.0077, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5388 Validation loss: tensor(98.4405, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n389 loss: tensor(186.4595, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5389 Validation loss: tensor(98.4281, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n390 loss: tensor(255.0041, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5390 Validation loss: tensor(59.2926, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n391 loss: tensor(117.9213, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5391 Validation loss: tensor(108.2446, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n392 loss: tensor(206.0414, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5392 Validation loss: tensor(20.1001, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n393 loss: tensor(255.0068, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5393 Validation loss: tensor(78.8749, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n394 loss: tensor(206.0443, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5394 Validation loss: tensor(78.8788, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n395 loss: tensor(186.4604, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5395 Validation loss: tensor(78.8821, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n396 loss: tensor(166.8718, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5396 Validation loss: tensor(78.8830, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n397 loss: tensor(264.7923, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5397 Validation loss: tensor(108.2492, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n398 loss: tensor(196.2488, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5398 Validation loss: tensor(59.2841, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n399 loss: tensor(284.3814, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5399 Validation loss: tensor(108.2517, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n400 loss: tensor(254.9955, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5400 Validation loss: tensor(39.7058, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n401 loss: tensor(255.0000, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5401 Validation loss: tensor(78.8809, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n402 loss: tensor(225.6336, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5402 Validation loss: tensor(29.9329, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n403 loss: tensor(235.4154, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5403 Validation loss: tensor(98.4647, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n404 loss: tensor(78.7432, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5404 Validation loss: tensor(69.0726, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n405 loss: tensor(147.2839, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5405 Validation loss: tensor(127.8358, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n406 loss: tensor(88.5386, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5406 Validation loss: tensor(127.8271, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n407 loss: tensor(245.2179, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5407 Validation loss: tensor(98.4490, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n408 loss: tensor(117.9207, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5408 Validation loss: tensor(186.5764, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n409 loss: tensor(49.3671, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5409 Validation loss: tensor(235.5378, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n410 loss: tensor(88.5339, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5410 Validation loss: tensor(196.3702, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n411 loss: tensor(166.8746, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5411 Validation loss: tensor(215.9617, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n412 loss: tensor(127.7118, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5412 Validation loss: tensor(215.9759, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n413 loss: tensor(117.9166, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5413 Validation loss: tensor(215.9784, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n414 loss: tensor(78.7457, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5414 Validation loss: tensor(137.6178, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n415 loss: tensor(20.0069, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5415 Validation loss: tensor(147.4334, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n416 loss: tensor(39.5817, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5416 Validation loss: tensor(167.0157, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n417 loss: tensor(39.5732, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5417 Validation loss: tensor(118.0793, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n418 loss: tensor(0.4150, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5418 Validation loss: tensor(196.4174, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n419 loss: tensor(59.1596, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5419 Validation loss: tensor(127.8792, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n420 loss: tensor(78.7475, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5420 Validation loss: tensor(225.7711, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n421 loss: tensor(39.5752, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5421 Validation loss: tensor(127.8460, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n422 loss: tensor(98.3282, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5422 Validation loss: tensor(176.8215, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n423 loss: tensor(39.5738, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5423 Validation loss: tensor(98.4911, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n424 loss: tensor(68.9542, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5424 Validation loss: tensor(108.2880, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n425 loss: tensor(78.7545, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5425 Validation loss: tensor(108.2745, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n426 loss: tensor(49.3744, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5426 Validation loss: tensor(108.2679, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n427 loss: tensor(19.9953, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5427 Validation loss: tensor(127.8414, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n428 loss: tensor(49.3745, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5428 Validation loss: tensor(118.0474, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n429 loss: tensor(68.9563, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5429 Validation loss: tensor(118.0519, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n430 loss: tensor(68.9580, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5430 Validation loss: tensor(157.2178, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n431 loss: tensor(78.7527, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5431 Validation loss: tensor(137.6239, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n432 loss: tensor(0.4068, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5432 Validation loss: tensor(235.5432, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n433 loss: tensor(59.1573, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5433 Validation loss: tensor(98.4649, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n434 loss: tensor(98.3291, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5434 Validation loss: tensor(59.2904, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n435 loss: tensor(19.9894, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5435 Validation loss: tensor(137.6275, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n436 loss: tensor(98.3270, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5436 Validation loss: tensor(176.8115, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n437 loss: tensor(59.1485, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5437 Validation loss: tensor(39.7233, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n438 loss: tensor(78.7422, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5438 Validation loss: tensor(157.2302, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n439 loss: tensor(19.9892, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5439 Validation loss: tensor(108.2572, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n440 loss: tensor(49.3612, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5440 Validation loss: tensor(127.8400, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n441 loss: tensor(98.3125, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5441 Validation loss: tensor(196.3925, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n442 loss: tensor(98.3168, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5442 Validation loss: tensor(118.0621, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n443 loss: tensor(19.9741, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5443 Validation loss: tensor(108.2727, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n444 loss: tensor(78.7244, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5444 Validation loss: tensor(147.4404, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n445 loss: tensor(68.9371, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5445 Validation loss: tensor(137.6363, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n446 loss: tensor(137.4951, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5446 Validation loss: tensor(167.0101, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n447 loss: tensor(98.3242, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5447 Validation loss: tensor(137.6366, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n448 loss: tensor(88.5202, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5448 Validation loss: tensor(98.4759, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n449 loss: tensor(39.5656, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5449 Validation loss: tensor(98.4669, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n450 loss: tensor(68.9402, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5450 Validation loss: tensor(157.2146, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n451 loss: tensor(59.1522, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5451 Validation loss: tensor(147.4229, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n452 loss: tensor(59.1492, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5452 Validation loss: tensor(78.8643, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n453 loss: tensor(108.1080, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5453 Validation loss: tensor(157.1976, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n454 loss: tensor(39.5710, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5454 Validation loss: tensor(186.5935, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n455 loss: tensor(0.4050, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5455 Validation loss: tensor(88.6645, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n456 loss: tensor(59.1518, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5456 Validation loss: tensor(157.2087, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n457 loss: tensor(39.5709, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5457 Validation loss: tensor(127.8165, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n458 loss: tensor(59.1507, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5458 Validation loss: tensor(147.4000, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n459 loss: tensor(78.7364, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5459 Validation loss: tensor(313.8515, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n460 loss: tensor(59.1675, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5460 Validation loss: tensor(166.9697, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n461 loss: tensor(78.7506, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5461 Validation loss: tensor(176.7557, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n462 loss: tensor(78.7484, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5462 Validation loss: tensor(157.1706, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n463 loss: tensor(98.3302, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5463 Validation loss: tensor(127.7832, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n464 loss: tensor(78.7469, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5464 Validation loss: tensor(196.3378, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n465 loss: tensor(39.5780, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5465 Validation loss: tensor(284.4681, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n466 loss: tensor(39.5754, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5466 Validation loss: tensor(157.1730, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n467 loss: tensor(59.1632, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5467 Validation loss: tensor(157.1748, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n468 loss: tensor(78.7428, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5468 Validation loss: tensor(108.2152, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n469 loss: tensor(117.9137, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5469 Validation loss: tensor(78.8410, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n470 loss: tensor(39.5781, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5470 Validation loss: tensor(157.1687, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n471 loss: tensor(0.4151, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5471 Validation loss: tensor(137.5944, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n472 loss: tensor(78.7489, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5472 Validation loss: tensor(137.5962, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n473 loss: tensor(98.3346, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5473 Validation loss: tensor(157.1886, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n474 loss: tensor(59.1630, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5474 Validation loss: tensor(166.9807, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n475 loss: tensor(78.7463, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5475 Validation loss: tensor(98.4303, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n476 loss: tensor(117.9181, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5476 Validation loss: tensor(186.5736, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n477 loss: tensor(39.5850, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5477 Validation loss: tensor(176.7462, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n478 loss: tensor(39.5798, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5478 Validation loss: tensor(186.5298, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n479 loss: tensor(137.5072, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5479 Validation loss: tensor(157.1618, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n480 loss: tensor(78.7571, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5480 Validation loss: tensor(78.8140, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n481 loss: tensor(98.3348, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5481 Validation loss: tensor(176.7305, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n482 loss: tensor(98.3397, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5482 Validation loss: tensor(176.7340, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n483 loss: tensor(29.7872, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5483 Validation loss: tensor(39.6453, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n484 loss: tensor(157.0919, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5484 Validation loss: tensor(108.1675, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n485 loss: tensor(166.8996, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5485 Validation loss: tensor(98.3921, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n486 loss: tensor(157.0917, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5486 Validation loss: tensor(59.2092, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n487 loss: tensor(196.2604, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5487 Validation loss: tensor(157.1424, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n488 loss: tensor(39.5966, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5488 Validation loss: tensor(117.9703, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n489 loss: tensor(147.3135, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5489 Validation loss: tensor(117.9520, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n490 loss: tensor(117.9377, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5490 Validation loss: tensor(118.0027, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n491 loss: tensor(176.6900, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5491 Validation loss: tensor(29.8718, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n492 loss: tensor(196.2688, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5492 Validation loss: tensor(0.4782, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n493 loss: tensor(137.5287, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5493 Validation loss: tensor(88.5999, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n494 loss: tensor(127.7295, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5494 Validation loss: tensor(69.0284, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n495 loss: tensor(59.1785, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5495 Validation loss: tensor(39.6462, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n496 loss: tensor(137.5215, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5496 Validation loss: tensor(20.0599, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n497 loss: tensor(186.4865, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5497 Validation loss: tensor(20.0584, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n498 loss: tensor(215.8620, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5498 Validation loss: tensor(59.2330, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n499 loss: tensor(225.6550, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5499 Validation loss: tensor(59.2275, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n500 loss: tensor(176.6897, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5500 Validation loss: tensor(176.7325, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n501 loss: tensor(225.6657, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5501 Validation loss: tensor(78.8271, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n502 loss: tensor(206.0752, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5502 Validation loss: tensor(39.6594, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n503 loss: tensor(215.8803, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5503 Validation loss: tensor(98.4325, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n504 loss: tensor(196.2814, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5504 Validation loss: tensor(157.1628, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n505 loss: tensor(235.4559, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5505 Validation loss: tensor(157.1675, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n506 loss: tensor(284.4158, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5506 Validation loss: tensor(147.3740, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n507 loss: tensor(225.6589, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5507 Validation loss: tensor(137.5726, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n508 loss: tensor(176.6990, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5508 Validation loss: tensor(294.2366, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n509 loss: tensor(294.2094, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5509 Validation loss: tensor(274.6504, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n510 loss: tensor(304.0051, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5510 Validation loss: tensor(343.1839, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n511 loss: tensor(313.7805, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5511 Validation loss: tensor(264.8608, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n512 loss: tensor(264.8216, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5512 Validation loss: tensor(411.7437, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n513 loss: tensor(352.9583, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5513 Validation loss: tensor(431.3239, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n514 loss: tensor(431.2868, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5514 Validation loss: tensor(509.6649, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n515 loss: tensor(294.1989, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5515 Validation loss: tensor(431.3263, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n516 loss: tensor(264.8332, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5516 Validation loss: tensor(323.6126, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n517 loss: tensor(470.4593, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5517 Validation loss: tensor(294.2566, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n518 loss: tensor(392.1213, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5518 Validation loss: tensor(304.0429, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n519 loss: tensor(352.9457, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5519 Validation loss: tensor(352.9919, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n520 loss: tensor(480.2414, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5520 Validation loss: tensor(245.2765, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n521 loss: tensor(372.5336, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5521 Validation loss: tensor(245.2963, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n522 loss: tensor(382.3391, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5522 Validation loss: tensor(264.8832, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n523 loss: tensor(401.9025, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5523 Validation loss: tensor(176.7642, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n524 loss: tensor(519.4193, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5524 Validation loss: tensor(98.4660, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n525 loss: tensor(421.5446, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5525 Validation loss: tensor(108.2148, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n526 loss: tensor(480.2505, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5526 Validation loss: tensor(59.2458, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n527 loss: tensor(558.6012, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5527 Validation loss: tensor(88.6246, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n528 loss: tensor(362.7671, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5528 Validation loss: tensor(78.8385, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n529 loss: tensor(558.6013, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5529 Validation loss: tensor(59.2433, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n530 loss: tensor(431.2889, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5530 Validation loss: tensor(49.4772, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n531 loss: tensor(529.2323, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5531 Validation loss: tensor(98.4114, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n532 loss: tensor(519.4241, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5532 Validation loss: tensor(117.9917, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n533 loss: tensor(529.2269, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5533 Validation loss: tensor(78.8120, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n534 loss: tensor(519.4113, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5534 Validation loss: tensor(69.0032, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n535 loss: tensor(411.7095, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5535 Validation loss: tensor(98.3936, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n536 loss: tensor(470.4548, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5536 Validation loss: tensor(108.1848, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n537 loss: tensor(323.5644, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5537 Validation loss: tensor(39.6480, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n538 loss: tensor(352.9514, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5538 Validation loss: tensor(59.2265, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n539 loss: tensor(186.4813, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5539 Validation loss: tensor(98.3872, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n540 loss: tensor(255.0267, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5540 Validation loss: tensor(20.0389, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n541 loss: tensor(196.2689, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5541 Validation loss: tensor(0.4668, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n542 loss: tensor(39.6032, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5542 Validation loss: tensor(20.0450, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n543 loss: tensor(147.3035, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5543 Validation loss: tensor(20.0410, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n544 loss: tensor(117.9300, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5544 Validation loss: tensor(39.6319, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n545 loss: tensor(176.6850, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5545 Validation loss: tensor(20.0388, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n546 loss: tensor(186.4891, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5546 Validation loss: tensor(0.4581, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n547 loss: tensor(98.3508, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5547 Validation loss: tensor(0.4709, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n548 loss: tensor(49.3944, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5548 Validation loss: tensor(0.4615, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n549 loss: tensor(108.1376, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5549 Validation loss: tensor(0.4614, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n550 loss: tensor(88.5495, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5550 Validation loss: tensor(0.4696, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n551 loss: tensor(78.7690, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5551 Validation loss: tensor(0.4520, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n552 loss: tensor(108.1394, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5552 Validation loss: tensor(0.4707, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n553 loss: tensor(88.5509, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5553 Validation loss: tensor(0.4570, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n554 loss: tensor(98.3411, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5554 Validation loss: tensor(0.4665, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n555 loss: tensor(108.1372, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5555 Validation loss: tensor(0.4533, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n556 loss: tensor(78.7494, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5556 Validation loss: tensor(0.4586, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n557 loss: tensor(59.1784, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5557 Validation loss: tensor(20.0389, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n558 loss: tensor(0.4211, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5558 Validation loss: tensor(0.4545, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n559 loss: tensor(19.9991, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5559 Validation loss: tensor(0.4497, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n560 loss: tensor(59.1797, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5560 Validation loss: tensor(0.4553, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n561 loss: tensor(20.0064, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5561 Validation loss: tensor(0.4488, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n562 loss: tensor(0.4352, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5562 Validation loss: tensor(0.4369, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n563 loss: tensor(0.4221, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5563 Validation loss: tensor(0.4425, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n564 loss: tensor(0.4217, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5564 Validation loss: tensor(0.4412, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n565 loss: tensor(20.0020, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5565 Validation loss: tensor(0.4506, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n566 loss: tensor(19.9940, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5566 Validation loss: tensor(0.4461, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n567 loss: tensor(0.4096, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5567 Validation loss: tensor(0.4521, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n568 loss: tensor(19.9869, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5568 Validation loss: tensor(0.4562, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n569 loss: tensor(0.4127, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5569 Validation loss: tensor(0.4405, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n570 loss: tensor(0.4108, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5570 Validation loss: tensor(0.4396, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n571 loss: tensor(0.4109, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5571 Validation loss: tensor(0.4396, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n572 loss: tensor(20.0032, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5572 Validation loss: tensor(0.4405, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n573 loss: tensor(0.4067, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5573 Validation loss: tensor(0.4328, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n574 loss: tensor(0.4184, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5574 Validation loss: tensor(0.4536, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n575 loss: tensor(0.4190, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5575 Validation loss: tensor(0.4494, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n576 loss: tensor(0.4212, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5576 Validation loss: tensor(0.4347, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n577 loss: tensor(0.4142, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5577 Validation loss: tensor(0.4417, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n578 loss: tensor(0.4297, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5578 Validation loss: tensor(0.4473, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n579 loss: tensor(0.4176, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5579 Validation loss: tensor(0.4438, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n580 loss: tensor(0.4197, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5580 Validation loss: tensor(0.4450, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n581 loss: tensor(0.4128, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5581 Validation loss: tensor(0.4471, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n582 loss: tensor(0.4196, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5582 Validation loss: tensor(0.4453, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n583 loss: tensor(0.4223, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5583 Validation loss: tensor(0.4447, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n584 loss: tensor(0.4109, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5584 Validation loss: tensor(0.4417, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n585 loss: tensor(0.3967, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5585 Validation loss: tensor(0.4548, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n586 loss: tensor(0.4033, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5586 Validation loss: tensor(0.4517, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n587 loss: tensor(0.4083, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5587 Validation loss: tensor(0.4360, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n588 loss: tensor(0.4143, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5588 Validation loss: tensor(0.4468, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n589 loss: tensor(0.4196, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5589 Validation loss: tensor(0.4462, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n590 loss: tensor(0.4076, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5590 Validation loss: tensor(0.4486, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n591 loss: tensor(0.4146, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5591 Validation loss: tensor(0.4409, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n592 loss: tensor(0.4065, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5592 Validation loss: tensor(0.4473, device='cuda:1')\n690 loss: tensor(0.4003, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5690 Validation loss: tensor(186.6222, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n691 loss: tensor(0.3865, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5691 Validation loss: tensor(215.9758, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n692 loss: tensor(0.3910, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5692 Validation loss: tensor(196.3955, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n693 loss: tensor(0.3974, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5693 Validation loss: tensor(108.2686, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n694 loss: tensor(0.3820, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5694 Validation loss: tensor(176.8061, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n695 loss: tensor(0.3879, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5695 Validation loss: tensor(225.7724, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n696 loss: tensor(0.3929, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5696 Validation loss: tensor(108.2695, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n697 loss: tensor(0.3873, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5697 Validation loss: tensor(176.8111, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n698 loss: tensor(0.3854, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5698 Validation loss: tensor(157.2404, device='cuda:1')\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n699 loss: tensor(0.4001, device='cuda:1', grad_fn=<AddBackward0>)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n5699 Validation loss: tensor(167.0394, device='cuda:1')\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"#scene prediction\nfor i in range(7100,7101):\n    previous_scans=[]\n    for j in range(i-15,i):\n        pcd4d = extract_pcd(directory, files[j])\n        bevmap = convert_scan_bevmap(pcd4d,0.2,1000,device2)\n        previous_scans.append(bevmap)\n    pcd4d = extract_pcd(directory, files[i])\n    current_scan = convert_scan_bevmap(pcd4d, 0.2,1000,device2)\n    print(current_scan.max())\n    plt.imshow(current_scan.cpu(), cmap='hot')\n    plt.show()\n    #feed into PPN\n    appn_pred_gpu = aPPN_gpu(previous_scans,current_scan)\n    #prediction loss\n    previous_scans=[]\n    for j in range(i-15,i):\n        pcd4d = extract_pcd(directory, files[j])\n        bevmap = convert_scan_bevmap(pcd4d,0.2,1000,device1)\n        previous_scans.append(bevmap)\n    pcd4d = extract_pcd(directory, files[i])\n    current_scan = convert_scan_bevmap(pcd4d, 0.2,1000,device1)\n    print(current_scan.max())\n    ppn_pred_gpu = PPN_gpu(previous_scans,current_scan)\n    ppn_pred_gpu2 = ppn_pred_gpu.to(device2)\n    afuture_np = appn_pred_gpu.cpu().detach().numpy()\n    afuture_pl = afuture_np[0, 0, :, :]#batch=1,channel=1\n    #plot the image\n    plt.imshow(afuture_pl, cmap='hot')\n    plt.show()\n    #mssce = MSSCE(appn_pred_gpu,ppn_pred_gpu2,0,0,device2)\n    #print(f\"MSSCE loss: {mssce}\")","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:57:48.500740Z","iopub.execute_input":"2024-08-09T07:57:48.501029Z","iopub.status.idle":"2024-08-09T07:57:49.131744Z","shell.execute_reply.started":"2024-08-09T07:57:48.501004Z","shell.execute_reply":"2024-08-09T07:57:49.130871Z"},"trusted":true},"execution_count":40,"outputs":[{"name":"stdout","text":"tensor(1., device='cuda:1')\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"name":"stdout","text":"torch.Size([1, 1, 1000, 1000])\ntensor(1., device='cuda:0')\ntorch.Size([1, 1, 1000, 1000])\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}]},{"cell_type":"code","source":"\"\"\"#training IOU\n# Hyperparameters\nlearning_rate = 0.0001\nearly_stopping_threshold = 0.01\n# Optimizer\noptimizer = Adam(aPPN_gpu.parameters(), lr=learning_rate)\ntraining_losses = []\nvalidation_losses = []\nfor e in range(0,1):\n    for i in range(15,700):\n        previous_scans1=[]\n        previous_scans2=[]\n        for j in range(i-15,i):\n            pcd4d = extract_pcd(directory, files[j])\n            bevmap2 = convert_scan_bevmap(pcd4d,0.2,1000, device2)\n            bevmap1 = convert_scan_bevmap(pcd4d,0.2,1000, device1)\n            previous_scans2.append(bevmap2)\n            previous_scans1.append(bevmap1)\n        pcd4d = extract_pcd(directory, files[i])\n        current_scan2 = convert_scan_bevmap(pcd4d, 0.2,1000, device2)\n        current_scan1 = convert_scan_bevmap(pcd4d, 0.2,1000, device1)\n        #feed into aPPN\n        appn_pred_gpu = aPPN_gpu(previous_scans2,current_scan2)\n        #corresponding segmented training scene evolution\n        ppn_pred_gpu = PPN_gpu(previous_scans1,current_scan1)\n        ppn_pred_gpu2 = ppn_pred_gpu.to(device2)\n        #feed into loss function\n        loss = IoU_loss(appn_pred_gpu, ppn_pred_gpu2)\n        optimizer.zero_grad()\n        loss.backward()\n        optimizer.step()\n        training_losses.append(loss.item())\n        print(i,\"loss:\",loss)\n        if loss.item() < early_stopping_threshold:\n            print(\"Early stopping: Loss reached threshold (\", loss.item(), \")\")\n            break\n        # Validation loop\n        with torch.no_grad():  # Ensure no gradients are computed\n            for vi in range(5000+i, 5001+i):  # files for validation\n                vprevious_scans1 = []\n                vprevious_scans2 = []\n                for vj in range(vi - 15, vi):\n                    vpcd4d = extract_pcd(directory, files[vj])\n                    vbevmap2 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device2)\n                    vbevmap1 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\n                    vprevious_scans2.append(vbevmap2)\n                    vprevious_scans1.append(vbevmap1)\n                vpcd4d = extract_pcd(directory, files[vi])\n                vcurrent_scan2 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device2)\n                vcurrent_scan1 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\n                # Feed into aPPN\n                appn_v_gpu = aPPN_gpu(vprevious_scans2, vcurrent_scan2)\n                #corresponding segmented training scene evolution\n                ppn_v_gpu = PPN_gpu(vprevious_scans1,vcurrent_scan1)\n                ppn_v_gpu2 = ppn_v_gpu.to(device2)\n                # Calculate validation loss\n                vloss = IoU_loss(appn_v_gpu, ppn_v_gpu2)\n            validation_losses.append(vloss.item()) \n            print(vi,\"Validation loss:\", vloss)\n# learning curve after training\nimport matplotlib.pyplot as plt\nplt.plot(training_losses, label=\"Training Loss\", color='blue')\nplt.plot(validation_losses, label=\"Validation Loss\", color='orange')\nplt.xlabel(\"Training Iteration\")\nplt.ylabel(f\"IoU Loss \")\nplt.title(\"Learning Curve for Scene Evolution\")\nplt.legend()\nplt.show()\"\"\"","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:57:49.133139Z","iopub.execute_input":"2024-08-09T07:57:49.133584Z","iopub.status.idle":"2024-08-09T07:57:49.143691Z","shell.execute_reply.started":"2024-08-09T07:57:49.133550Z","shell.execute_reply":"2024-08-09T07:57:49.142782Z"},"trusted":true},"execution_count":41,"outputs":[{"execution_count":41,"output_type":"execute_result","data":{"text/plain":"'#training IOU\\n# Hyperparameters\\nlearning_rate = 0.0001\\nearly_stopping_threshold = 0.01\\n# Optimizer\\noptimizer = Adam(aPPN_gpu.parameters(), lr=learning_rate)\\ntraining_losses = []\\nvalidation_losses = []\\nfor e in range(0,1):\\n    for i in range(15,700):\\n        previous_scans1=[]\\n        previous_scans2=[]\\n        for j in range(i-15,i):\\n            pcd4d = extract_pcd(directory, files[j])\\n            bevmap2 = convert_scan_bevmap(pcd4d,0.2,1000, device2)\\n            bevmap1 = convert_scan_bevmap(pcd4d,0.2,1000, device1)\\n            previous_scans2.append(bevmap2)\\n            previous_scans1.append(bevmap1)\\n        pcd4d = extract_pcd(directory, files[i])\\n        current_scan2 = convert_scan_bevmap(pcd4d, 0.2,1000, device2)\\n        current_scan1 = convert_scan_bevmap(pcd4d, 0.2,1000, device1)\\n        #feed into aPPN\\n        appn_pred_gpu = aPPN_gpu(previous_scans2,current_scan2)\\n        #corresponding segmented training scene evolution\\n        ppn_pred_gpu = PPN_gpu(previous_scans1,current_scan1)\\n        ppn_pred_gpu2 = ppn_pred_gpu.to(device2)\\n        #feed into loss function\\n        loss = IoU_loss(appn_pred_gpu, ppn_pred_gpu2)\\n        optimizer.zero_grad()\\n        loss.backward()\\n        optimizer.step()\\n        training_losses.append(loss.item())\\n        print(i,\"loss:\",loss)\\n        if loss.item() < early_stopping_threshold:\\n            print(\"Early stopping: Loss reached threshold (\", loss.item(), \")\")\\n            break\\n        # Validation loop\\n        with torch.no_grad():  # Ensure no gradients are computed\\n            for vi in range(5000+i, 5001+i):  # files for validation\\n                vprevious_scans1 = []\\n                vprevious_scans2 = []\\n                for vj in range(vi - 15, vi):\\n                    vpcd4d = extract_pcd(directory, files[vj])\\n                    vbevmap2 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device2)\\n                    vbevmap1 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\\n                    vprevious_scans2.append(vbevmap2)\\n                    vprevious_scans1.append(vbevmap1)\\n                vpcd4d = extract_pcd(directory, files[vi])\\n                vcurrent_scan2 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device2)\\n                vcurrent_scan1 = convert_scan_bevmap(vpcd4d, 0.2, 1000, device1)\\n                # Feed into aPPN\\n                appn_v_gpu = aPPN_gpu(vprevious_scans2, vcurrent_scan2)\\n                #corresponding segmented training scene evolution\\n                ppn_v_gpu = PPN_gpu(vprevious_scans1,vcurrent_scan1)\\n                ppn_v_gpu2 = ppn_v_gpu.to(device2)\\n                # Calculate validation loss\\n                vloss = IoU_loss(appn_v_gpu, ppn_v_gpu2)\\n            validation_losses.append(vloss.item()) \\n            print(vi,\"Validation loss:\", vloss)\\n# learning curve after training\\nimport matplotlib.pyplot as plt\\nplt.plot(training_losses, label=\"Training Loss\", color=\\'blue\\')\\nplt.plot(validation_losses, label=\"Validation Loss\", color=\\'orange\\')\\nplt.xlabel(\"Training Iteration\")\\nplt.ylabel(f\"IoU Loss \")\\nplt.title(\"Learning Curve for Scene Evolution\")\\nplt.legend()\\nplt.show()'"},"metadata":{}}]},{"cell_type":"code","source":"# computation time on cpu+gpu\nimport time\nimport torch\ni=15\ntppn_gpu = autonetwork().to(device1)\nstart_time = time.perf_counter()\n# Run some things here\nprevious_scans=[]\nfor j in range(i-15,i):\n    pcd4d = extract_pcd(directory, files[j])\n    bevmap = convert_scan_bevmap(pcd4d,0.2,1000,device1)\n    previous_scans.append(bevmap)\npcd4d = extract_pcd(directory, files[i])\ncurrent_scan = convert_scan_bevmap(pcd4d, 0.2,1000,device1)\n#feed into PPN and aPPN sequentially\nppn_pred_gpu = PPN_gpu(previous_scans,current_scan)\nprevious_scans=[]\nfor j in range(i-15,i):\n    pcd4d = extract_pcd(directory, files[j])\n    bevmap = convert_scan_bevmap(pcd4d,0.2,1000,device1)\n    previous_scans.append(bevmap)\npcd4d = extract_pcd(directory, files[i])\ncurrent_scan = convert_scan_bevmap(pcd4d, 0.2,1000,device1)\ntppn_pred_gpu = tppn_gpu(previous_scans,current_scan)\n\nelapsed_time = (time.perf_counter() - start_time)\nprint(f\"Model inference time (might include non-GPU operations): {elapsed_time} seconds\")","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:57:49.145479Z","iopub.execute_input":"2024-08-09T07:57:49.145783Z","iopub.status.idle":"2024-08-09T07:57:49.606957Z","shell.execute_reply.started":"2024-08-09T07:57:49.145760Z","shell.execute_reply":"2024-08-09T07:57:49.605648Z"},"trusted":true},"execution_count":42,"outputs":[{"name":"stdout","text":"torch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\nModel inference time (might include non-GPU operations): 0.15865542799997456 seconds\n","output_type":"stream"}]},{"cell_type":"code","source":"#model with parallel dual neural networks\nclass Model(nn.Module):\n    def __init__(self,PPN_gpu,aPPN_gpu):\n        super(Model,self).__init__()\n        self.pyrnet = PPN_gpu\n        self.autonet = aPPN_gpu\n    \n    def forward(self,directory,files,i,device1,device2):\n        previous_scans1 = []\n        previous_scans2 = []\n        for j in range(i-15, i):\n            print(j)\n            pcd4d = extract_pcd(directory, files[j])\n            bevmap1 = convert_scan_bevmap(pcd4d, 0.2, 1000, device1)\n            previous_scans1.append(bevmap1)\n            bevmap2 = convert_scan_bevmap(pcd4d, 0.2, 1000, device2)\n            previous_scans2.append(bevmap2)\n        #load current scan\n        print(i,r\"(current)\")\n        pcd4d = extract_pcd(directory, files[i])\n        current_scan1 = convert_scan_bevmap(pcd4d, 0.2, 1000, device1)\n        current_scan2 = convert_scan_bevmap(pcd4d, 0.2, 1000, device2)\n        \n        pyrnet_out = self.pyrnet(previous_scans1,current_scan1)\n        autonet_out = self.autonet(previous_scans2,current_scan2)\n        \n        return pyrnet_out, autonet_out","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:57:49.608181Z","iopub.execute_input":"2024-08-09T07:57:49.608497Z","iopub.status.idle":"2024-08-09T07:57:49.618460Z","shell.execute_reply.started":"2024-08-09T07:57:49.608471Z","shell.execute_reply":"2024-08-09T07:57:49.617405Z"},"trusted":true},"execution_count":43,"outputs":[]},{"cell_type":"code","source":"torch.manual_seed(44)\nmodel = Model(PPN_gpu,aPPN_gpu)\nfor i in range(700,701):\n    pyrnet_pred_gpu, autonet_pred_gpu = model(directory, files, i, device1, device2)\n    pyr_pred = pyrnet_pred_gpu.cpu().detach().numpy()\n    pyr_pred_pl = pyr_pred[0, 0, :, :]\n    plt.imshow(pyr_pred_pl, cmap='hot')\n    plt.show()\n    auto_pred = autonet_pred_gpu.cpu().detach().numpy()\n    auto_pred_pl = auto_pred[0, 0, :, :]\n    plt.imshow(auto_pred_pl, cmap='hot')\n    plt.show()","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:57:49.619698Z","iopub.execute_input":"2024-08-09T07:57:49.620541Z","iopub.status.idle":"2024-08-09T07:57:50.191643Z","shell.execute_reply.started":"2024-08-09T07:57:49.620492Z","shell.execute_reply":"2024-08-09T07:57:50.190755Z"},"trusted":true},"execution_count":44,"outputs":[{"name":"stdout","text":"685\n686\n687\n688\n689\n690\n691\n692\n693\n694\n695\n696\n697\n698\n699\n700 (current)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\n","output_type":"stream"},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"iVBORw0KGgoAAAANSUhEUgAAAakAAAGiCAYAAABd6zmYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8WgzjOAAAACXBIWXMAAA9hAAAPYQGoP6dpAABkEklEQVR4nO29f5Cd5Xnef2lX+0O77O6xhLSLbGQrLlOsQGyMsLzgaTpFtWzjto5pWjKKhySMaRzhGOPgQBvI2A6WQ9MkxXGg9jc1zBjq2DN1EzMxKSNaHGpZgAguBhuTwbZkyK4U1P3Brnf3sOf9/vGc6zzX++y7klbaPfsedH1mzpxz3l/n3TNwLt33c9/XvSbLsgzGGGNMCWlb7RswxhhjFsMiZYwxprRYpIwxxpQWi5QxxpjSYpEyxhhTWixSxhhjSotFyhhjTGmxSBljjCktFiljjDGlxSJljDGmtKyaSH3uc5/DG97wBnR3d2PHjh149NFHV+tWjDHGlJRVEak///M/xw033IDf/d3fxRNPPIE3v/nN2LVrF44cObIat2OMMaakrFkNg9kdO3bgkksuwZ/8yZ8AAGq1Gs4991x8+MMfxk033dTs2zHGGFNS1jb7A+fm5nDw4EHcfPPNjW1tbW3YuXMn9u/fX3jO7OwsZmdnG+9rtRqOHTuGDRs2YM2aNSt+z8YYY5aXLMswOTmJzZs3o61t8aRe00XqH/7hHzA/P4/BwcHc9sHBQXz/+98vPGfv3r34xCc+0YzbM8YY00QOHz6M173udYvub7pInQo333wzbrjhhsb78fFxbNmyBUNweaIxxrQiNQAjAPr6+o57XNNF6uyzz0Z7eztGR0dz20dHRzE0NFR4TldXF7q6uhZsb4NFyhhjWpkTLdk0/Te+s7MTF198Mfbt29fYVqvVsG/fPgwPDzf7dox5VdIOoFMe7cnDmFZhVdJ9N9xwA66++mps374db3vb2/DHf/zHmJqawq/+6q+uxu0Y86qAAtQBoBvxX6A1APP1fW3yvirbCd/PJ+fOw5jVYVVE6t/+23+Lo0eP4tZbb8XIyAje8pa34IEHHlhQTGGMOTlUoPoA9CIvSEAQLiAKVBV58eFrilSt/n6m4FgUvDdmJViVPqnTZWJiAgMDA9gMr0kZA4SUHiOojfXXSrtsowDNYGHE1C7HcN8MgFnkRQxyvsXKnAo1AC8iFML19/cvelxLVPcZYxZHBaqCEEml605tiCJFQWpDiJCAhQKk27m+NSefh/r1NMqyWJmVwCJlTAvDdaYOAD0ABurPQBCjNjlOo6QO2c5tQBCgdJ1qrn4tihHXu7rr+6YRxEojM2OWC4uUMS2KFklsQIigKvX3M3IMn9PUeEfB6w7EtSie0418oUV3fd9cfVsngIn6OVXEiMuY5cAiZUxJSVN288k+FajNCCLVnRzfnpyj29uwsCS9AzHVx+vzcylSTPcxwtKobAb5gg1HVuZ0sUgZU1LSVFy6rx1BmDbWH0zDsXJPrwFE8VCBSo9hZV83gvjwAcRUIN/zesDC1KJGVBYqczq4OM6YEnKiKIppOIpUBTFVN7/Ig9eZk+Nqct008tEoa7HIi+thHYjRXRvyImjM6eBIypiSwn9BFq3xtCMUSAwhiFQXgEnEdSKm5lIRqsp7vm5LjlOhO96/YtNKQGNWAouUOeNRh4WywIjleKm+XoRIqgtBKCYR1oS0B6od+bUpXW/S6Ioila4nsUiC++eS8yCv9To1lO87Na2JRcqc0aSl2WUgXTMqog2xkq8G4CiAUcSoS0WiqEGXxQ+8Fs+heFWRr/RjuTm3673OyIPHpFFc0d/IezLmeFikzBlLGQWKcH0nvS8KGNeiehEiqMMIQqXHFfny6f70deo4QZFqQ75pt0OOY0PvrByTrosV/W1ljF5NObFImTOaMv9QLvYj34kgThxewyhqrP4+7Yk6nlClwlRUjp4KuRZKsIqPAqVR1PG+W5enm5PFImXOWFLH77LBqERhhLUesWn3BQAvIV/AoI7nKlhFKbi0cAKIEdKMbOO1OhCtmChkPDa1WSqirN+3KScWKXNGU7YfzDQFWVR63oPQwNuNEEGNY3GX8jRSOlm0gVdJBY0ir44UxiwnFiljSoKO22AqLf3R70QomKA/H4sV0uvo6+MJx4kEbLF1LOJGS7PSWKSMKQkUqB4UCxR7o9YjOp2rR1+RPx/3AQsjK2Dx9arFrqHPTPcdr4rPmNPFImXOWMq0HsU1nh4A/YhFEETXooYQ0n0TCGLWnRwH5OdEaVVeUWSkKbtUcNICDPUM7EEsgVdT27J8p+bVgUXKmFVGx21o1V56DAca9iJfHl5B3j0CyJeCp/OeasmxkO3pMUqbPLN4ohOxArATbuI1y49FyphVRiMUrkcVOZ73IIjUAKI/ngqWCgz9+YDoPsHtRZ+vUdRiUZUez+P4nvdjzHJjkTJnLKv9L37+2KtxK1N3qWNEN0KabwhxPYou6KkA0RaJsExcHcyRXF/fpyKX2iAVCZjNZM1KYZEyZpVgBNKJkOLrrT/mZD8QHc8riGtAFDG6jqeo1REQxUkLMtK0H9OHtD5Kj2NEVuQmsdqCb169WKSMWQXSKjmaxfYgb+LKtZ4BhMGGjLRoJKsWQxolFQmPFkgAC2dOsfKPzbmQ7bquxeMZcTGycpWfWQksUsasEixA4FyoAUSnB4oBm3dfi1DZh/r+KSwsU9ehg0Sn5qZpPYqLOp8XlbGrqKVpPa0etNWRWQksUsasAu3y6EAc/V4FMF0/hqnASrJ/DNGGaFaOVQskCg6jm9SwlutgqTUUt6sLe9pbxW2MxKrI+/YZs5xYpIxZRRgp9SEI0jhClKQ+eYOIXn0jiCM5VBQ0fciUYLq2lI7Y0DUpXX8qKozQKCmNmNJ7MWY5sUgZ02TSUexcj5pFTONpFMXmXSAI1AvIV96l6b0eed+JICKps4RGQnytkRHPScvhdV0qHXC42FgOi5c5HSxSxjQZtTCiQPUipPlmEIsl1AKJ4+FHkJ8bVXRdtUrS9SUtb9diCr5OS9A1Kkt9BbWx93hYoMzpYpEypoloFMWCCQrRYcTpuHSSeD2i4/mLAI4hiNVisPCC4sEJvBxcCBRbH7EAQt+zqIPbuhCjKBVZV/WZlcQiZUwT0R94puZ66/vU0bwXQbxei1D1B4SCCaYDF4NpO6b3UgNa4PiO53ocr6cVgh0Fzx3JOcYsJxYpY5pEuhbFCbt0hJhGPoLZgFjVN4lQVAEUWycV+e5pYUQ6YXexaIriyW1adLGYSBmzklikjGkSacMtIymK0JQcU0Go6qsgCNnR+n7Uj0/9+oCFEZYK2fGq9Xgst1MoKZxdKF57YhTl/iizklikjGkSmhKj1RFFawxBEPhj34UQRfXVjx1DEA86j1McVHxSp/P55LiiMfFFPVDcDoT0o/ZM0VmiQ967/NysJBYpY5qErkexeq8b4Qd+DHnPvu76Q4saGHlxTEZqU1QUVWmpOZAvXVdxoZClokVRKmr45efQosmYlcAiZUwTSNejuOZUQfiRH0fok2JqrYLY4DuBkA7U0RxpY24aJelIjiqKRYSFGjp3Kp09lY7gmE/+jhk4kjIri0XKmCagURRdJgbq28YAvIQgGCxI0NLvcQSRYpqNhRXpqA91n9DoSSM0FZMuRAGjawQjI57fKeelEVO1fl/0GjRmJbBImTOWZrshaFUfq/bmEFwkKEJATPWxx2kS0YUi9fwD8tV+2pzLz0xFiutTHPlOkZrFwqGIRZN+yQzCOtrxSuKNOV0sUuaMphlClRYmsIm3D+FH/ihiPxOjrApiAy6Fg+tQkGPT17pelH42K/bSc9Pzmb5L04RMDVKs6MbuKMqsJBYpc8ayGr5yHYgDDtsR0nxjiH1M9OvT6jkKWDoOQ3uYtHRcCyDS6CftrVLaC7YVoffh9Siz0likjGkCXItiwcRGBFF4EfnRHPTrY+UfEMVUhxFqc26bHKvl6TyX0VMXoghpkURaGs+IK/X+Y1qQ6chpGLPyWKTMGUkzbXx0DakHcfTGDPKpvnaEKGoj8j1UbKqdQX5irg45TG2KUrcJIAqZzpBi9KU9V1qJqNfStSye7yjKrDQWKXNGciIfu+X8HEYnnQD6EcvIaRiraTvOlmK0MoOQEnwJMZLSKKldzuW21KposXlSKNjOdS8VPh7Lxl5NRRqz0likzBlLs6IA7Y0aQBCiWQA/Qiw8YMXfRoRoqoIgBkcRhIxVeFrQoEUSaYRVZImkQsbjgJgi1NSe3jOjrM7k/CIPQGOWG4uUOSNJS61XCo1YuhDEpxshMvoJ8ms/FURT2Z76PgoUsNCeSFFniTSVSbHirCo1k2VDLkveNRJL3Sp0/crj4k2zsEgZs8Lwh78fQYBYMPGSHNOJWJrOtaPp+jE12daNhQMK1biW4nM8dI1JzWSB/NgNHX6o8PObJfTmzMYiZcwKoQ4TFKBKfR8jJKb6uhCKKdYjlqePIaQFOQ6eEVDqt8fXi3noFXn8pVGQFl6wyRj1e9OGXq5JLWZMa8xyY5EyZgXRtR2m8cYRCyGAKGIb68dwui6tkljplzpGADFdqMKTGsWqSHE/bZDSY9PP4Oeo+LFi0E4TphlYpIxZYShCPQiRCRt4gbxNElOB7QipvmP1132IUYyWlgP5ERypqznkGJ6jQqbmsOnaE41ka4tsm4NFyjQHi5QxK4R69anV0SjyjbAdiA2+LE+fQBARrcjTtSZW2mk5Om2LuL2oHyoVKYoNBatoPUujtDRqc+GEWWksUsasACoqHLHRjSAOY8hHId0Ia1H9iEJCd/Fu5EnnOqmpLLdp6i5t+IVsU5FhBWEt2U7R08gpLd4wZiWxSBmzgnDAIdeV5hFESiMgrkd1IfYl0flchxsCC7349L1aJWnaTz8rRd3TmTpMz00Nax1BmWZikTJnBM1ymNDP40ObdMeQb7ylQA0h9lBNIfY0aSGECpWuUbUtsp0U/c2ctkthY2EGRVWr+1iGTkHVWVbGrDQWKXNG0Mx/+WuarQPRMJZl5erVR0NZFk0witIRHfTsS4scikSKn5keA+TH0fOY1KlCLZLoQqHX6IIFyjQXi5RpeZodJZ0I9dPrQFyPAha6nvciRFEUMiBEUhwmWKu/H0cUqHSIYfr3t6M4xacRkJrK6rpVpxzfKceoea0WXxiz0likTEvDNFRZBIrQD68XQYC6ESr2XkR+NPt6BFd0lqDPIq5HAeHvmkYQqqJycSBfcUeKfPh0uq8WZMwn56m3X1p4QZFy4YRpFhYp0/KU6ccyLRXvlsdI/aHVeZX6o7P+mESImrguBSwUhFSUNcJK+6h4PJ/TUfMpWsKO5JqLefoZs5JYpIxZAViAMIDoIjGCIECEruiV+jPHxY8hRiuMXli+DhTbIqlxLGR/OtCQ1ApeU7x43ByKU3qOokwzsUiZlqZsP5Zc1+FsqAqiX9+LiNERCypeiyBQvfXtRxHTfbqGpGm4onJ0NuemjhOpyOh4Dj1usc9IhY8VhBYq0ywsUsYsE2ooS6ujDQhidRTBaYI/7BwjP4CYhhtDGN8xg1hpx/4qGr3q2lLaM0UBnMdCASuKqmrJOXyeQ1gb08/Tv3EKFijTPCxSxiwjLFLoQEzjAcCPETz7KBa9CAUTtELqRhAyrlnRHokilZaap9V59NNj1KPCMpccRxh5aRowtTsqEkJWHhrTDCxSxiwzbcg38M4AeB75/qgBhNJzWiHNIKQDpxAESqvw0lJxXoOGsel03rSwQe2QKDppg7A6onPkR5HpbBWOpExzsUgZs0xoFZ26mk8iREnsN+pB7I1iSTfXotRjT9NzGvHUUFyZRzqRj5h0Yu+JepsoVkXj6GcQ0oCzJ7iGMcuJRcqYZYCRDVN0Ogb+eUS/PgrYZgSh6qufN4mQRuNIDy0lT4sgFitqQLJ/se1pQy/3tcu2oj4rHueJvKaZWKTMq55mOFJoVV8f4oTdGoDDiJEJvfo2IPYsMZKak21AHO9O+yJuT0e6FzlOqJBwnUmv3Z48iqK39PUcnOYzzcciZV71rPQPq0ZRnYguE30IxRIjiGtHmuqjeet0/aGipM25tEni36LOEYyAVJhoZ8R7U4GkGKlHH89Px3xo4y+wMKIzphkUzThblL179+KSSy5BX18fNm3ahPe973149tlnc8fMzMxgz5492LBhA8466yxceeWVGB0dzR1z6NAhXHHFFejp6cGmTZtw44034pVXXjn9v8aYVYI/8pwNxXTf0fqDKbQ+RJHqq59LM1ktTmAV3SRCqvCl+uOYPB+tP6evX6qfM1Y/fwrRwYIVfVqWzoZhjhThqHs+ehGrDQFHU6a5LEmkHn74YezZswff/va38eCDD6JareKd73wnpqamGsd89KMfxde//nV89atfxcMPP4wXX3wR73//+xv75+fnccUVV2Bubg7f+ta3cM899+Duu+/Grbfeunx/lTFNhBEHf/B7EBtxRxGEAggisAEh3UcxYJECoykKFB80l52Ux3TyfgxRuFSwJhEn/KbX5baiMfDqcsHXOqLemGayJsuy7FRPPnr0KDZt2oSHH34Y/+Sf/BOMj49j48aNuO+++/Cv//W/BgB8//vfx5ve9Cbs378fb3/72/GNb3wD733ve/Hiiy9icHAQAHDXXXfht3/7t3H06FF0dnYe7yMBABMTExgYGMBmLFFljVlmKExs3h0E8FYAb67v+xKAxxGij40ALgGwA8C59WMnATyHIGYjiGtPFJUpxNEdwMLx8EWTc3UuFMdzaPqOAjSfHN+N6HwBLJxT9SOEMvkxOJoyp08N4b+n8fFx9Pf3L3rcaf3Gj48HJ7L169cDAA4ePIhqtYqdO3c2jjn//POxZcsW7N+/HwCwf/9+XHjhhQ2BAoBdu3ZhYmICTz/9dOHnzM7OYmJiIvcwpizomlQFsT9qEiGi4TEsmmCqrxfR5Vydz9vkQeHorZ9DL8AKYvWgmtgy6umUazAaSu+3qOBCP1ur+uaQn2llTLM45cKJWq2G66+/HpdddhkuuOACAMDIyAg6OztRqVRyxw4ODmJkZKRxjAoU93NfEXv37sUnPvGJU71VY1YMrZDTAYZ0PWeqj47nA8in0GYRUnVcK1JhAILYtCM/bJDHqYdeFfn1Jo2eOpLrdWChQOnfkzYDs8FXBzEa0yxOWaT27NmD7373u3jkkUeW834Kufnmm3HDDTc03k9MTODcc89d8c81rw5WqgRdx3JwgGEFMWU2ipCuA+LsKK5HsbGWa0lAjIR0rQoI4qcVferdp+M8NNLRogggWim1JdtZdajfUU0ePEbXzIxpJqckUtdddx3uv/9+fPOb38TrXve6xvahoSHMzc1hbGwsF02Njo5iaGioccyjjz6aux6r/3hMSldXF7q6uk7lVo1ZEfjDrsavrIrrRvgxfwFRRLoQRKqCaHs0j7C+M40QYTHK6UbsmaJl0mJ+fWqFNI18hSDvM03nUZA4CkTLziHXoADPIFYJOtVnms2S1qSyLMN1112Hr33ta3jooYewdevW3P6LL74YHR0d2LdvX2Pbs88+i0OHDmF4eBgAMDw8jKeeegpHjhxpHPPggw+iv78f27ZtO52/xZimoms3rOrja1ohMbLpRvDpA6IwzCCOhdfrAfm0XDeCyKUVd13Ir0dxfaoX+TWq1EKpSGjoJJFWAfL9GBxFmdVhSZHUnj17cN999+Ev/uIv0NfX11hDGhgYwLp16zAwMIBrrrkGN9xwA9avX4/+/n58+MMfxvDwMN7+9rcDAN75zndi27Zt+MAHPoDbb78dIyMj+J3f+R3s2bPH0ZJpCVK3Bh3N0YMgDD9CTOPRhWIAeZFhdMJrFn0ORatIWNJ0Y7qOVOSIXmRUm8JqPqYMXTBhVpMlidSdd94JAPin//Sf5rZ/8YtfxK/8yq8AAP7oj/4IbW1tuPLKKzE7O4tdu3bhT//0TxvHtre34/7778eHPvQhDA8Po7e3F1dffTU++clPnt5fYswirNRaFCObNsQBh/31/c8jFk2017dvqB9DoZpCEAR1gkjdHLgGlU7cBWLhBFN66d/JlGBbsq0TC8WPZfQdyfGp64Qxzea0+qRWC/dJmdVC+6K6EFN4gwAuBfAzCKLz/yH2R1UAbAfwz+v7N9bPeQrAAYRIpQ/51KB+HiMZ/reeRkxItlPYGAkxjafVfnRfVxHj/jFEs1tWKT5X327McnGyfVL27jNmiWiKjxEVnSQqCIayagTG/ij2OLUhukyQ1K8PiALEY1ORSosi1LsPWJjWS9e01PsP8szzdU3Lfn1mtbBIGbME9AedAtGJKEA9CGtRY4gC0IPo5Ue/vlkU+/VxZpOauk4jpAa1Kk/dIFKzWYqYlrOn5rEUnqLGXqb8emWbMauFRcqY04RiwB9/2hsB4cd+A6LrOdeeGB1RlFSkgHw0pW4U3LbYOlFqfwTkBYyl7zqnSosu0h4rjfCMWQ0sUsacAlw7YuVeBbE/iqXnqG8bREj3sUSczg00i2VkxLWntLGWFK2/pgUV6m7O/RTPNLVXlWNU8Fj2zr4sTUEa02wsUsacAoxK6DKxHiHlN4qwGMwf/V7ECbz062N/1BiilVFncl0tLwcWDjoE8mXhKmhalq7XSs9vl+OKqgO5f7ZgnzHNwiJlzBLRwgn69dEE9jBCJMXj6DLB1BsjpsOIIsXmW5aMpw24Wp0HFAtTUUpO+7hI+pr2R0V+fW2I62HGrBYWKWOWQBqd9CM6m7chNPGyP6oDcSRHP4KorWkDjtbCcRSoHkRHdCCub2k/1BxitEUxorjweUbOYbGEXkvnXnGbClUNMWJj0cRkcl1jmo1FyphThO7kTOVVAfwYsfihD0HAeuvHtQGYr+WjLbU0YlSkviudiAUVHYiRFlHvPm3qLYq80llU3Mb3jNhqsi8t2jCm2VikjFkCmh4DosNEJ4L4HEYUDM6AYuRF1/NRhB/+CmKfVWqxpG4RHXLNxdaVgHwq73gFFRpJcb+O/eC2GYTJvhYps5pYpIxZApru60ZI861HEJK/Qz7VtxHAZuSdz48i/PhXEHumtFyc52o1nvYzpVV2acOulqCn+3lM2yLbeQ4r+ziiw6k+s5pYpIw5SdqT1yw95/rN9xFEiuLCBl8KVA2xyZfl6NqfRAFi5ESY7qNw6Wtt7NUSc63m43W1yi+NwPiZfK2fa5Eyq4lFypglwmiFzuZ9COJzONlfQX7kBvugOhGEi9EKEJ3HgWiBRHGZSrZxHQqIItWJKHT8vLTsnHZIRSM81OtP17Kc6jOrjUXKmCVAAepBSOfx8Rjyfn09CP1R9PNT0eFsKKDY7QHyvor8SI9UOChKWhTBaEjdzilk6t2XfhafO+sPN/CaMmCRMuYk0aID9kh11t8fRX5yrfr09dSfGelo4YW6TNDZoSrHVhGKF7jWBSyMblK/Po7/QP3+0pQg16SKREjThfQWNGY1sUgZc5KkjbBM2c0D+Amiq3k7QvS0ETFqIVxTSi2JVJTSeVGzWNhoq+em1y9yjyhCy9b1+hSwKpzuM6uPRcqYk0AjDArUeoQoaR4hklLD1g0IQtUDYF0HMFeNqbtUEJC8T93OtUwdyIuYNhZrmXnRGlNRRR/kfAoe04SexmvKgEXKmJNEf9R7ENJ57QgR1Jgcx1QgUE+79QE4Fo4ZQ5zIq8MGme4DYnRGYepFXqSq8qzu5ukUXgpM2luV7geKU39Ti2w3pplYpIw5CVSgupEfA8/5UUD44e+q7+9C3cqorhxjCIKmTbrqUk5x4gworlF1IaT8uF9FimgkRehmoX+DRmV6PMWNUdQ0ggmuIymz2likjDkJNA3XgWgK240YIaF+TD+CXx9FDO1hHWoU0d6I1XZArNBT7z4gRkqz9fMoJDpzSnujtEqQ96mVf0U9Uu3JM687BRvLmnJgkTJmiaizeAfCkEMdBd+IoIQxxHUrRj30ygOiESxfa2OvRjy6zpRGQfpMDz7tqWL0xGPSEnT9HA5kdCRlVhuLlDEnSZs8+hAjqWPIp942IDpNdADAfCiYmEOMknStRyM0vk8bbavJ+3Q9Sde30m3pupJWAxatV1URx4gYs9pYpIw5AalosCm2u/76GOKIizaE9agKYnEFqnFabzcWTsFNq/U0hUdSM1h9rd5/Wu3Hptyiybppek/TfqxCdNGEKQMWKWNOgIoUx3NwTaq9DRirxVQZx25QLNZ0AZjOpwOBvDDpLKhULDgkcUaO57FMGTK1yM9UW6Siv4XHpak8njsBp/pMebBIGXMc+MPNYocOhHTeAIIgzdWiaSxL0zkuvrt+gbnZsJ/CpoavRZV6qU2SjtHQhl81pYXcJz+D98xrqSWSjgPRKI1+guqeYcxqYpEyZhHUBol0IgoQiyaOyf5uRL++DgCoxihIU3HpmpNSFGWx0k5L05W050q3aUMwBUpnVPEzefx0wT0Zs1pYpIw5DvpDz6hKe49eRN5Xr0/2twPA/ELbIx37rqk8dX1Ij0n9/eqXbjzTE1An8vK1Clp6rm7XqMvrUaYsFKWtjTGCRikc0cHKvcMI03Z5HMd30Ckd3Yv/4Kcl5PyMom3czihIp/kyOkuHGaal8mnaMp0pxWt50KEpE46kjFmEVBz0h5zVdM8jihBTgVx7WlNXhRmElCAbcrVCT1OAQLE46DRghRFP0T7uT8VLI7UUXY9yus+UBYuUMSdAI5cehOo+Fj38GHnPvQ31YzoQT6JtUtowC+RFUCMrpuk4FkSbfVWQuK6kkZVeu+gcPXc+OXZc7tWYMmCRMqYA9bnT6bq9iM26xxAKJxiVdCPYIfUhWCOxfnwMceS7NtLqZ2kqrhf59Seey0uqmSzXyChiqX0T+7L0s/m3pN5/7QipS3v2mTJhkTJmEdLoQ50m2hB+0I8hpvC6EQSmE0B7VzhnYjocp3OjNE2n1+ZnqvMEECv8KEKs+mMRhjYItxW81mZdID94MbVGOgo7TZhyYZEyZhG4fqM/9Gr+ymm8jEjoMDGP+onT0WkCyA8SZKOu7ksNYLWHSnultGdKy8tVjBg9UYyKGng11TePUKV4DI6iTLmwSBlzknBNij1SY4hRRztCf9TG+n7UgPlaLAPXwgWKgBYvaJ8SEEWlmpxDx4l0qCGrDdNrLBat8VlFbQz5uVjGlAGLlDEnQNenNLWmqbEOSAMvwkG0F2IUNIcY8dDrT3uSmIbriZdY4H4OuZb69lXlOosVS6Tj5tMiCzufmzJikTKmAO1BYlFDD+KwwxryThMVhCiq0exbi+k9Vv+xjF3TehQipv5YFJFGO9pATJHR4gl9sFKQrymIjLS0QVntk9zEa8qIRcqYRdDKuW6Eir0KgPUIa1EvIq4bDSCIVC/yqT1GUqy+60C+Wk+9+YgKWVXuQ2dM6T32Ibqu83NYyKHXotBRnCiGvN4MoqAaUxYsUsYUkDbZArH/qR0h1TeCKDaV+gOoC05bEIExRMEAYmqOQkUh4z5GX0BeMNL5U1r23phblaBrX/xbeN4cFnr3TcKRlCkftkUyJkF7kvjjTjeJvvr7HyMWGbA0vQsyMh7Rl69TtqfrRYxoUlKPPY2I1O2c0VP6P3K6rsTUn15b980giJTXo0zZcCRlTAFpUYGuR3UiRFKz9f0UMHWGmJ+Na0EshGBzrjbkAgtLzzUC0gq+tIx8XrYzHZiuZemaVfq5KsCTsNOEKScWKWNOQAdiSo1FDkeR/0GnXx/q2+cQRYzCwgo8TelRYFSgNCUHOY7C0ynXTK2QCAsy1C5JP5fwXFb2GVM2LFLGHAcK1HqESKoX4cd+EvEHn2k+Ck4nYh+TlnvzMYcoTCyOSN3KNR2ohReEoqfFHazUg9xLb3If2vSrI+/17zGmTFikjFkELUGvIK4r6fpNO0LV33rkI6m0CRdYWGWXrn0h2c9rsdhCj+F1db2LIsV9FDye0ybX0VQhEHq6LFKmjFikjDkBaTptBCHdB4QfeS39npPtVYQ0WmpHdLzPKJoJBUTRA/KOE+lARV1zUn++dDyHVgcyMqRweV3KlAmLlDHHoWho4HMIfVLzCOm0IcSqP1bQqX0RsLCqLy3MSNecSFrlN4dYNail7bzXNIWo5eqpRRL/nknE9SgLlCkbLkE3JiF1DNcChBmEQYeTiKnAAURx4f9QU8iXdDMFWBQF6Zyp1NtP983JNWYQCjPUeFahYKaRGeH4kW7EiM8CZcqIIyljErTQAIgCVR8PhReR719iZV99OgfmEARqOrmmupprao3rRCxk0LWttIk3daZAsj9dg1KqyXEsrphEEFVjyohFypgErcTrRrQd6kaIXsbk2H4EO6QBxGGFHFQI5Kv11DOP+4o+m89aDNErx2jxQ0/9wf2MkCi0RXZK7N3i36g9X8aUDYuUMYKm+hhtdCKWmY8gTK5lGTeLJniu+vW1YWHqUKMbTeFphKQFEJqCU7cJilAvYiTHbfwMrm2l73XNq4oQGbpHypQVi5QxCbqOQ2FghDKOUK5NQehDECrun0FMnWlFXVqOztSe+vgBcYxHWi6u86QoaMezRSL8fK5P6bpZfS7jgsZkY8qERcqYRaBAqQhoaqwd0c8vFQpt6tXrAQtLwdW/rz15v9j4DI2q+GAExvEcGskx5TiXnD+GsCZlTFmxSBmzCBQIXTuaRHQQZySlxwKxCpCpPCBfvUcPv6q8V5iy4zkaPaU+frqGVSRmaSGFzqDqRBCpicW/AmNWHYuUMceB6z5cd3oJecFgxERrIvYvqQilPVEUFD5zjago5aaCxGGGNKyl0wSjJO2b6kT0+IPsV3ukboTI0OXnpsxYpIxJUDukHoTKPQoQ+6MoCFyTStN9alvEUu/0M3Qarzbg8nrao6Ul7hQephk1Jcn75rV43zyP1+xFiOBGYTskU24sUsYUwAiI0UhRkYGKAFN4wMJqPZ7PdJ965zGdmEZbvAcgX0yh5/K8dE5Ukccfr6eR3TEAL8BRlCk3FiljEjQtpsUHI4g9UhQHpvuAKETT8h6IBRTabIvkdSpAhNV/vCbXu3TSbxui0KhAFVX86f4XESIpi5QpM7ZFMiZBixNY5s1BhzSMBfL+d4y4GPUA+TUhHq+pRE3PKbqmNYdQ0j5V/+wpBKFMHSJ07Sqd4ptaI/GeX0BMXxpTVhxJGVNAmibTmUs6CkPFjBENU30somDpd1Ue6unH42YRo6Qu5KMovgZiVDWDfOqR618akTHi0wpCCtdRuInXlB+LlDEFqC0SI40x5H/sOQyxF6GIYU0HMF+N5wP5ke7crlN5gZgiHKs/c1R9ei8qdtzeLQ/9XGBhsQbXv/rq13ATr2kFLFLGCIyOWHreI9tmkBcdeuaxwg/IDydUivqYmNKbRHCyOIo4ioMCxFQdX2txhM6xopt5asXUgXxfV3v9njkTyyJlyo5Fypg6aaMsS761ak/pRSz3rskBTA8WjekA8vOgjiEKBp0fmFbU0nc24U7KdVSgNEIji7mk99Q/81jx12BMqbBIGVOANtACQRwmkV+PYlqOVX3qAAF5zcIIFkRMIUROkwjFC6PIT8alKGkVH8vH1V2dTcYUxHQMPdem2NjL3q4a4kwsY8qORcqYhLSMmyLAaby6XqVpNEYuaTECq/QYTR1DiJxGkBcofuYcQhHFFKLAaaqQKcguxBSgulgAC0ULcn9TCCLlJl7TClikjBF0Uq426AL59SZGWdzW3gNk0zGVx4iI16TocO3pxfqDwqefD0Q3dS1313TkLPLWSzqiQ6v7KKSsKuSQwx/D61GmNTitPqnPfOYzWLNmDa6//vrGtpmZGezZswcbNmzAWWedhSuvvBKjo6O58w4dOoQrrrgCPT092LRpE2688Ua88sorp3Mrxiw7/JHvRai604inDaGybyPqJrM9wJq2IC4c21Fk7jon15rD8YWC5rMahenns09LS82ZHqRdkvZysQBjDPnBjcaUmVMWqcceewz/5b/8F/zcz/1cbvtHP/pRfP3rX8dXv/pVPPzww3jxxRfx/ve/v7F/fn4eV1xxBebm5vCtb30L99xzD+6++27ceuutp/5XGLNMaOSiBq4TyKfHuCbVcIioAVO1IEAqHh3JdTrl3F7kBxAeDy3C0LRe6q4+lRwPRIHj547JcW7kNWXnlETq5Zdfxu7du/GFL3wBr3nNaxrbx8fH8Wd/9mf4wz/8Q/yzf/bPcPHFF+OLX/wivvWtb+Hb3/42AOB//s//iWeeeQZf+tKX8Ja3vAXvfve78alPfQqf+9znMDeXDi0wpnnoD7am+ZiuU8si9iY1RsVPxkIEihGP6ZDXPYgRWAXFI+QXo2i2VCpefF1UxEELp1H5e4wpO6ckUnv27MEVV1yBnTt35rYfPHgQ1Wo1t/3888/Hli1bsH//fgDA/v37ceGFF2JwcLBxzK5duzAxMYGnn3668PNmZ2cxMTGRexiz3OiPttoKtWPhSItOhDQfS9CnqiGS4Zh5PjNdyNeV+nksXz9V9FxNBaaRUVWO70QsmtD1MmPKzJILJ7785S/jiSeewGOPPbZg38jICDo7O1GpVHLbBwcHMTIy0jhGBYr7ua+IvXv34hOf+MRSb9WYU0L99fij/xLyIsAxGzOIYy+4LqQFDUCMcvRfhCyMWGqF3bw8WM6uc6S0jF2r++YRxHEEQaQsTqZVWFIkdfjwYXzkIx/Bvffei+7u1HRl5bj55psxPj7eeBw+fLhpn23OPNLiBDbd6g8703i0GqI7BXuZWE3Haj8WP0whlqCPY+FU3pO9P157FtHLj/1Qiloqof65L53CZxqzWixJpA4ePIgjR47grW99K9auXYu1a9fi4Ycfxh133IG1a9dicHAQc3NzGBsby503OjqKoaEhAMDQ0NCCaj++5zEpXV1d6O/vzz2MWSm04IHrTi8l+3sB9CNaE3V2xNJvrewDoqiMIZR+P48Q0aRO5ku9RxVTPlNUmd7jdlYYHq3fhyMp0yosSaQuv/xyPPXUU3jyyScbj+3bt2P37t2N1x0dHdi3b1/jnGeffRaHDh3C8PAwAGB4eBhPPfUUjhw50jjmwQcfRH9/P7Zt27ZMf5YxS0f7kLQqj4UThPtVHIAYQSnV+rljCOL0LIDDyJezn8p9sqRdiyQYXemYD51vxXHxs3BVn2kdlrQm1dfXhwsuuCC3rbe3Fxs2bGhsv+aaa3DDDTdg/fr16O/vx4c//GEMDw/j7W9/OwDgne98J7Zt24YPfOADuP322zEyMoLf+Z3fwZ49e9DV1bXgM41pBukcJu05Ut89CgKLHxpJ7/m8MawOI5xAjKBewEJHilO5V5ayawWhpvXUFmke0QCXJrbGtArL7jjxR3/0R2hra8OVV16J2dlZ7Nq1C3/6p3/a2N/e3o77778fH/rQhzA8PIze3l5cffXV+OQnP7nct2LMSaPTeIF80YSOh2eRQgVRINoB/LRe/03RYqqtiuAs8RxC6fdyzG9qQ7RGKhoprwUbs4g9X0BIM6Zl7GVHU5vmzGNNlmXZat/EUpmYmMDAwAA2w6OFzfKQrkNtBnApgH+MIDh/gJCmqyJEUe8H8AsAzkXoe5pBKITgtFsgiNIIgMcAfAenl+IjnfV72wVgG2LVXl99Xw/yLumo/11vRPh/ZTeAb9W3t8IPv87RMq8uagj/gBsfHz9unYF/441B/MFmtMRog2k1TaPR3JWCtqYLWNcWq/04wHAMIb2WmsguF1qgQYEqutduAO0doapwJe5jpUgbks2ZiQ1mjamjAwW1mVf7krif61E93FAD5mv5cnMdJb/cKSs1k9Wx8Zr6y40baQsViq00nqNVxNSsLBYpY5AvnABi8y0jk9S3j+7iQNg5Vw0CMIXordeBheXop0v6w82RHEDegJY0IpEO4MXZ1jSWtVid2VikjCmAfUZFE29VgNa0AVk1ptLYUMvKvhdX4N7UnV0LPnhfFNhcY28NeAatZ4fUKvdpVg6vSRmD4ghErY/U5ogiUUNM8R2t7xtALE8HQuSyEutAnLTLNGRVtisUsbnpvEgZ0ypYpIxBfvQFkPfb4xgMXcTnpF5df6L7BNexJrGyDg9s1GV/Vps82MzbjSCaxxAKOIxpNSxSxmDhGAx1lNCJvAqjqXaEvqkNiCm4MQSBonv6SsCoidFSrrkYMp6jK5TPj8DpM9N6WKSMSVBTVqbStChB3R0oZn0IkRQn7/KxEqk+RnZ0OufaWSqqFCn0BrFspco+Y4gLJ4zBwuo+fU1H8/R47a3qQHQlryJW/y11FMfJ3qt+PoUy/azGCI954EfwepRpTSxSxtTR6IjRCdeWONwQiALWLe/nEKfd9tW3FZWELwcdiMUZOkuKf4MeBwDz49Etw5hWw+k+YxAr5SDPVQSBYmotFRz+6NcQU2ksnqghFCusxJh29m+xaGNGHryvqfr79rY46NDWQqYVsUgZg/wE2xoW/uhrUQWLJVTYNALrQBCJl7AyKTadADyJOJ5DR3RM8567Q6+Wx4SaVsUiZQyiONG7ryqPGeRdI/g/TS/iWhZLvbk29SJWrqqvA9Gnj9HUHGK5/DTy61HPIYhZK/ngtdK9mpXFa1LGJLB6jmk+jaqAfNFCO2KVHV8fqz93Y2X+FUghpQUThWoSUVQblX3trVc0oQa5Lpk3jqSMEbRijwIwjuIfSxUxID+Zdz2AjYjzppYTphW59sSG3kmE/qwqwv/YXQhvnkdrFU3od+2IyjiSMqYOm2IZqfCHf6LgOP7ocxgie5PaEAQKCBZJ3Vj+/iS6r08iCBQNb9sQK/5YBv9CNaQe6YzeCrTKfZrmYJEyps68PGYQ7YzGkS+c0Iq6XkSh6kVcp5pCXNNazpQVCzS0go9VeyybZ9qvBuBZhOq+VqKVBNWsPBYpYwSm+ShSfCZ0RdcqQCAOQOypv59FTMMtNyziOIq8APUj9nVRbJ+CVPq1EBQqr0kZi5QxAqvkOA5+FiFi4eItf/xnkZ+C2wOgvQfonA7nrdSAQVYS0h+QFYTj9WeuUVXqf8NziGtUrYYFygAWKWMWwDTdFOK6j1JDTOeRdgCYD9tpKqt9VMsN51cx1TeJIF5MPfbU7+nYCt6DMc3AImVMAVUEoWEFn6Lj2RmhdADIZpMepRWCo0AoQBRN+vdxICJF1phWxiJlTAKr4xgtLVZ+Tq8/IJafs/GXQrLca0HtCGtPHNNRRUw7co1MRWxqmT/fmGZjkTKmAFb4LSYyWjQBxFJwNvWyuXa5U22M4FhdyOuzoZj3TZFttYKJFLWrMmcmFiljCjjRjyIn8DLdp959s4iVgStlLktB4rqYjpHnvdH5wphWphWLfoxpCix8SKMRloCzLwmIVXf07htb4XvTzya8124Et4sxRKFs1b6jVr1vs3xYpIw5ReYQoxkK2RSCOLQjGM52Fp556qjTeXuyjetnGwAMITqktzJO8xmLlDGnQEfBe4pVB4DNAM5FEKqV8O7rRSyYSP8n7kP4cT+MV0fhhIXqzMZrUsacBKn7AYsSdEwGhaNSP2YIoV9pbBnvow0hOuOoDhZqUAjp48dBh62OBcpYpIw5CfTHkj1UkwhRC8UKiG4QHJexUmsq0/WHphq7ZP9PEIxliX/sTavidJ8xS0AHIvK9Fk0wBVdFEA0OQlwJ0kZjurcDwbm91dejjAEsUsYsGfrm6dh2IIoRm3p7EcZ2LLf7BMVJJwmTGoI46uBAY1oZi5QxS4SNvKymm0+2s4m3D8BrEartllMs2CjM8nLeC90nNiAWchjT6likjFkiHNfOIYlA+B+JNkqsvluPUOG3GcsXTbF6UFOI2qvF/6FXwu3CmNXAhRPGnAK0JaJYTSOuRQGhwq+K0FQ7iOVbl2I1H4WKYzjaEASM93AUrW+JZAzgSMqYU4JptnT4IW2LuuR1P0IktRwpP5bCs7IvbSZuR36qsDGtjkXKmCWSFkpodV9n/bkm+3oQIqvliKYoPKlvID+L5rM81kJlWh2LlDGngPZGATEFx6m9jG5qCOtTg/Xn042maojrTRxZr+k+rln1otjfrxVox8r2mJnWwiJlzBLRCIYPHS8/J8d1IBRQnIewPnW60RTTjJ0I1YMsyGDBBoWrQ45vRSxUhrhwwpglUkOMXtQuib1LTPn11be3I1gkVer7TqfJlp81gLDWpU4X3QhrYa3sep6S2lGZMw+LlDEnoCjdoL59TMEx3QdEeySKyHKmLKqI/n0TyM+26kasOny1pEksVGc2r5b/jo1pGtqPRMcHRi8sDecaERAq8X4C4CUsj1VR0Y+2Rk/HEMSzgtaNqOaTZ3Pm4kjKmCWgdkOMnNoRU3xAiGKO1R8TAP4OwFMIvUtzWB7SSI3M1D93I4Dtcg+tFI3ML/LanJlYpIw5AVyDAvIuEzXZRmYRIqYxhOjpRwCeAfBjLN9spyqiu4WmE1W06BlIw9tWxAJlAIuUMUumHWE9iDOdgCAINQSBerH+eAphptMIlt+RfBZRJNNoqhPRlonzrPyDb1oVi5QxS6QdC3ue5hDSeT8G8AJC9PQMQrptuQWCa15pqTtTkD0IVX6sKDy8zJ9vTDOxSBmzBNoRBKCn/p6FE9MIa0/fRxCq57AyAqU9WbrORJHqrT+qCNFdH1prPcqYFFf3GbME5hFEgKPh2xAEYQyhQGEcIaJaKRdyNrjStw+IxrIUzw7E9GJfeoEWg0Up5szFImXMEmhH+OHvrb+nuSwNX5mKW6liBe3D4mewcbiCvJltD/JpyVYsoGjFezbLi0XKmCVA9wi1JKIbOtNrvchPx11upuXzgLxIMbrTgg5jWhmvSRmzBOjFtx5BjCgGjLB66vtokTSG5U37qTdgD6JY9iE2Emu/1gDy6b9Ww2tpxiJlzBKgiav+eLKYgYULb6g/s29pYhk/n3ZMHQiR0zTizCpGU1qSzlHyqc9gq9Bq92uWH4uUMUukG2ExX3PlHJFRQYhwuhEKKI5i+cWBLhe99c8ZkM/sRRBFjgrpgdd1TGvjNSljCtAxEW3Jdq4B0QqJ+3VNiqm4fizf6Pj0XnQ0B4sluBY2g+BKwTSgMa2KRcqYBApROvKdaT3OdAJi+i01mOXa1WYEH73lKqPmYEMWTnTVr92NEMXpPc/XP3v9Mn22MauB033GJLQj+t4VjWDXijmOxWAUM4fYS7UBUcBoOrscBrP07NO1qI765/OeKFZF7hjGtBIWKWMERkMVhB/6KvKVcWwuZfHEYgMGmfpD/XoUlkksnxO6VhSyb4tOE/yMPrR+Q685s7FIGVOHxRC6tjSWHMMiCI2g2hBdyel0Tg89zp5ib9NRBFeKKZx6MUWHPHchPy6+PXndg9DX1YqVfcYAFiljclCoWPygpMMN1Vmiinwajk7k3L8eQZg65TOmsfSoqg2xko8CqSXxXDPjc5q6NKbVsEgZU0eNW7VyDrKdsAyd23WSrL5nepBrVKwI7ECI0iaR9+E7kZDwWryveeTnXRV5+6Via0wrYZEypgAON6QYMeJpr7+ekePYk8SR8TPyWl3Kaf5KI9iNCELF1GFVXs8jLzSQ66SDDOdlu27j88b6vuUaumhMM7FIGSOkfUgUFk3LaZl3tb6PIkFh6kAYTMjjNZrpQajKm0NIAzLtV5XXs4i9ThSrTuS9ASmMqYEsU45ArPRzr5RpVSxSxiDfvMvXnYhVfqn3HYcO6hqVupLr3KcOxPUprhFReCqIRRUziJ5/fF1FmPZL+yNtztUqPkZ4c8gLVw2xqfjoUr4QY0qCRcqYRVCbozHZPoOwllSpv+caEIUlTb1RNFhQwRlUFJbe+jaeD8T03zxC1DSOWCTRJtfV66WRFa9TATAI4Edw8YRpPZbsOPHCCy/gl3/5l7FhwwasW7cOF154IR5//PHG/izLcOutt+Kcc87BunXrsHPnTjz33HO5axw7dgy7d+9Gf38/KpUKrrnmGrz88sun/9cYs0zoOHYWSNCBnEMG+cxKupqcr+4TLJagQwQLMhjhrEdYN+LjtQhOFUOII+B5fAVxZhQFSgsl0tQf18fYR2VMq7Ekkfp//+//4bLLLkNHRwe+8Y1v4JlnnsF/+k//Ca95zWsax9x+++244447cNddd+HAgQPo7e3Frl27MDMTEya7d+/G008/jQcffBD3338/vvnNb+Laa69dvr/KmFNAowz+6KuTAxCEaBIxCpqX45lu4xBEDkLUwgjaGhGKDNOALH2vIIhXBbEht1J/dMg12JuVRkj8TCD2SxnTiqzJsiw72YNvuukm/J//83/wN3/zN4X7syzD5s2b8bGPfQy/9Vu/BQAYHx/H4OAg7r77blx11VX43ve+h23btuGxxx7D9u3bAQAPPPAA3vOe9+AnP/kJNm/efML7mJiYwMDAADbD5oNmedCoqQth3MY/RhCO7wB4AnENaSeAn0eIeHoQ1npeRHSUAGJfEsVnTl4z6upBvtAC9feMtihwzwMYQRSojQAurB/DwgpGdJ0IqUk6T9CR4isA7kPrzpUyrz5qCP/fjI+Po7+/f9HjlvQb/5d/+ZfYvn07fvEXfxGbNm3CRRddhC984QuN/T/84Q8xMjKCnTt3NrYNDAxgx44d2L9/PwBg//79qFQqDYECgJ07d6KtrQ0HDhwo/NzZ2VlMTEzkHsYsJ+l8KH3o+lJNjmGZeQ2xgo6pP5aQazHEfHKuPrfLtdXxghHUhvpDx8PPy7m6FsVmXm3g7cHymdwa00yWJFLPP/887rzzTpx33nn467/+a3zoQx/Cb/7mb+Kee+4BAIyMjAAABgcHc+cNDg429o2MjGDTpk25/WvXrsX69esbx6Ts3bsXAwMDjce55567lNs25oSkYznUwUGdI+YQG3A5Nl4FIe15mkm2cXttkeNYig7EdSyO/ehC3kSWMILi52ulIhDSjuvhlJ9pTZYkUrVaDW9961vx6U9/GhdddBGuvfZafPCDH8Rdd921UvcHALj55psxPj7eeBw+fHhFP8+cmRQZxaqtkBYjjCG/5sNU3yTyDbl8cK2Kj6mCB/dpEQZL4fm6hrjWxUGLrA7UcxhdUQQ3IkRkdkM3rcaSROqcc87Btm3bctve9KY34dChQwCAoaEhAMDo6GjumNHR0ca+oaEhHDlyJLf/lVdewbFjxxrHpHR1daG/vz/3MGal0ehKR3awWVYfjGLSCj969UHO1SiKTbuzso+owGn6UKM8beDVe22T7VyfatVIysJ6ZrMkkbrsssvw7LPP5rb94Ac/wOtf/3oAwNatWzE0NIR9+/Y19k9MTODAgQMYHh4GAAwPD2NsbAwHDx5sHPPQQw+hVqthx44dp/yHGLNcUBBoI9SLKDR0hSiq1EtdKDSC0rQeo6ZJhFHvfJ6o75tMjplOzuf1IdsJy+JTwetGWNNqNdLUpTnzWFIz70c/+lFceuml+PSnP41/82/+DR599FF8/vOfx+c//3kAwJo1a3D99dfj937v93Deeedh69atuOWWW7B582a8733vAxAir3e9612NNGG1WsV1112Hq6666qQq+4xZKViIQMcHVs1xPYg/mBQLdZRQl4lUvBgR1Qpe89iqHK+NvDyO0ZA6Sai3nxrOptZOHMI4gHwxRSugzh3mzGRJInXJJZfga1/7Gm6++WZ88pOfxNatW/HHf/zH2L17d+OYj3/845iamsK1116LsbExvOMd78ADDzyA7u7oJ33vvffiuuuuw+WXX462tjZceeWVuOOOO5bvrzLmNNGUWvojqes/KgI9CNEQsNCUltV4WinIMnNepyrHalOuOrJrihHJ8UVNxiqWG9B6UUkrCapZGZbUJ1UW3Cdllhvtk6Id0gUAzkOImv4cYfw7EHqo3gtgR/24OYReqefrzxQVpuGKxIiva/XzO+V5EEFQ+AM9gpD2Y4EEEJ0oeB32TFGUGBW2Iax3DQB4HMAdiELaKnhg46uTk+2TsnefMYuQGs4SrjPpDyddJorWqDRFx/caqXXKM+2O2HPF47XPClg4gFGvT/QfcIzEutB6WKDObCxSxiA/rDBtylX7IyA/70ltkLSJt1OuCUSR0euq8GklIde3+JkstlDRYjTGz1PvPp5H0dK1MxVO//ibVsAiZQwWDhFUrz0gH6VUEafq6nndiJ59FCWKAWdLdWFh5V3qRkHxYyqQhRr6WZMIBR2E0ZSWyXM7/54K8mtixrQCFiljkE+/pT/kTMMRlqEzymIF4BTCulUaeVFwioowjlfIwOo+bc7l57P0nKXxnXKtanIer0XnCmNaCYuUMYtQVCEHxMZdHkORGkNeWDQlx2MpdlyD4v7UVT2N0HoQCzC0fF3vU++PKUtGcmxAVosnY1oBF8cZUyctkNDhgqmB6zTyxRMseNB+J2Dh+hBftyf7GW0xxUdh4een6cj08ylG2uSr4zym6/fXqq4T5szFkZQxWOhInvYiabqPzb4qNnzmGpA23jIa0+sruialglRUHUgXCnVB52cdzwWdQrsB+TJ4Y8qORcoYLKy2A/LrPn3IV+ax4k5TbWlVXoc8p6k/IDqea+pQHdO1uo+FE5MIacUOOYb3k0ZRRULUg3wq0piyY5EyRuB6DlNkswjrOBtlfzuix94cohNEDxYWXRwvagLyAkTHiSnkByLyGB5fQ97Hbwb5hmGmDIGFPVR9BfdkTJnxmpQxdXS0hkY4fQhTeNMKP/ZDUaAoVtzG4gU6QmhKkaQ2SER9/vTYbnkg2ad9UEBM8fE+WIbeig295szFkZQxBVCoGDl1IR8lpe7jRMVCixq4JqWpv1SYiv7FSAHrTPbrdN602i9t0mVBBiOuVOCMKTMWKWMSNIph9LMBC+dCcR2IUUqRY3eRqwSQ75mqyWuKYepknm7T0vK5+nkUTXW9gBzDfi+LlGklLFLGLIJGQkzn6T5dS2J0pL1P2lCb9jVpoYb2NPXWH1xjKmou5vXTycBpajCd1svP7D3B321MmbBIGVMn9drj4EPOctK1HI6Ln0IQpinZN4koaGnPk1bl8XN0hEeRnx6jNlb/TcnxbPTtrO/T67BhmD1YxNZIppWwSBkjMM3HcnMKSlqUMI8gRpOIIzN6ZLuWoWu1nc6ZAha6WaQ9UzrckM26OpCxgugLqM2/OpsqvabTfaaVsEgZk6Bl6Mfz9KNYAPm1HhUhioKWh2sakWk4rjdpWhByHJJz0jUpvbdawXm8NhDL0O2CbloBi5Qxi8Aohs2x6iIBLJwplY7L4JoSr5WO0tDUHL37phGbfNM1Jn52t2zjsTyea1savWkVItfXOpAXU2PKikXKmEVQhwkgRCAaYbG0G8gLWS/iWhTdydVCCShOH/Izi+4j7dGisKmN02KRUWpa2wuvS5nWwSJlzHHQ1Fsfooms+uTp2hULGShCad+UDi5Mr5Fuh2xTs1v1BGR5epFAMdIC8tdkatIpP9MKWKSMSeAPOqvquPbUjfzaESfyMt1GwaDzBAsfikRE3S1mEcWninz6TlOHQN4iSe8RyK97zcjn07qJ+1w8YVoJi5Qxi0Ah4npSmiZjpZ1u60aouNMqv7RPCsiXuqeo+WtRIUXRfWpVIrdpxIf6fU5i4RBHY8qMRcqYBApLWom3EUGojtW36cgOIEZDPchHRGmFHyOcotlV88mzQnskFa0iEUvPZQqR99MNYD2Ov45lTFmwwawxi0AB4LoOoyTdP1V/qFgVeffxmVGXDlKkKW26RpWuVekaFB9afajFHLpONi/H8P5SmydjyoojKWMWIY10WBSh6btpRCGbQT5qYjSm12I0hPqzlo3z3G7Zx8/Wggk2CKtDRpFnYDr4kNC13f9CNa2ARcqYhHRMhkYg6ns3hzCAkDZImopjjxWjsDQtl47hAPITgVn+TqFjcQWQj9oomNpYzM9nik//HlYgugTdtAoWKWMEjU744z+JEDExktIG3UkAEwjl6T2ynalAFlak3n36eeyvAvIVenoPU/JeDW1Zcagl8Gm5O3u2eN0a4swrY8qORcqY40CRYBTSi7yIsQRd+5goGtPIixS3p04UPC9NL6rtEUVJR4RUERuMU/cKJU050vbJa1KmFbBIGZPAKESHBU4j/LD3IUQrOs59EvnoiO7p7GnSIgYtqEhLxIEggmmKTi2SaDJLsWNJuZbHpw7rfKjjOlN+bug1ZcciZcwJYDQzgyBSfQhrUUC+0ZbHaql5kXEsxUnFQUVPhUjtj4B86bpW8vHzgFhYATkOyAuiRl/GlBmLlDEJFAWKjApMB0IZ+gjyYsSUnjo60EaJpIaxOiCREY7aKaWRT2pMy+N7EK2YGCHpOleaikx9A40pMxYpY4Sice9M3zHV15eco427rObrQ0wFkjnEwYWaUtQJu2mKT9eRiu6TJeuLTe8F8uPp033GlB2LlDFCWniga1Isgqgg7yChKT4gRklaKg7khWRejkk9+rQJF8mzRnXaCKz3q427KdXk2WtSpuxYpIxZBIqFFi50INgjdSMIF6v/+KBotCFGVYxkZuS1rkuxbFzXiVLHCl2H6kj2pccraYovdZ4wpuxYpIxJYCpOBUrd0DciFk/U6s9jyA8jZBqOkc0M8hN1UzdyroFxHUrLzlWQ5pPraJSVVgQCeSFSCyUgiqkxZcYiZcwJSD31uhBSfqMIP/rH6o8NiG4RFCqNwihEGpXV5HiNqvSzdaihpva0hD0doKiVfkC+OZjPLqAwrYBFypgTkFoaqYs4DWbH6s9d9WMoPEyxpTZIKg6MaDrq56dCVZSWY/l5KjJpsUR7si0dfuiUnyk7FiljjgNTZxMAxhGaZtk8y/TcNICjiCm/Xjl3CqHCj7OltFhC+5l0oCLhIMUq8k3BWpAxh/x03tS1Qm2YNO1YRShb94ReU3YsUsYk8Mee6TQVGv7Qc83pWP34YwgiNlS/BiMdHj+GWPTAUvW0h4prWKQ9uQafWbChBrQ8Xl0n2pB3U59PHiynPwaLlCkvFiljCtB1JPY7jSEIVjeAAcR1qbn69peQL7Rgdd8MgoDpSHelo35sP+I6ljYR6xj76fpnqdOEClIXFjYDM5LSYgwgH/UZU1YsUsYUwChlDkEAphHHclQQBKUix6uQ9SEf4TCSmsJCuB7Fqjv6A6q4aGVhFWFsh65xtSOOCwFi6k8jMAoeG4p5HtelKKjGlA2LlDGLoK4QQH5tqAOheIJ2RWz6nZFzgYVFEEWfwWd1W9f0m5aq0wZJqwbTPiuub+kaVxq98Z5op2RMWbFIGXMctHSbIsVZTBWE9NoU4tgOrhcB+XHvKgap5RFZTMzU54/vdU2Kc654Xywt1wbeNjlX165OJKLGrDYWKWNOAm2SnUMsFe9EfjruBOJQQdKHIGiavlMrJJaLF/UtcTvXnBRtCKbYqAAB+YGHWg6vThQe2WHKjEXKmOOgKTMKEaMrlnATXVfSfqkNCBHWJOL6lq55pWLTiViVR9FhWrFIrFRo1AWdUPh0sCKPcarPlB2LlDHHQSvk2hHFpgehMm4AwOH6sazy47EdiEMMx5AvWlD/PPZDLeZ4DsQoidEQ5Nh0qq9eg1WCLORggUSR/58xZcTWXcYch9QfbwoxpcfIh7Cxlw2znXKMOlAwfdeFGCWp+0PazwTk15T0fRHpMET9W1jSri7o/hEwZcaRlDGLUFTcoPOfgCg4FBSt/uuQ/ekoDy1soBMFz+uUY1TciA5ARHIcSc9L039F0ZcxZcQiZcxxoHAAMV3GUnOm/JQq4ppTVc5lH5WayqpzOa/PyEyr9zh0USsN1fGcTbxAFDv9bL2+ilsVC6MtY8qGRcqYE6BmrkzpTSGsR6mzAxDEiOtSOjtqHMF+SAsVVJC08EE/F4i2TKmDBBDFiOcxbXg8kUrXtRxRmTJjkTLmBHC+E6MfRlKziCPl5+RY7ZWiWNE2SdeA6DaRVvCl0RvtkFj+rg4SQL7Zt1fuR9fCINfjffK9RcqUGYuUMScgjT7GEM1kNyKk/Sbq+6qyn1ENI5tJuRYQoyeKFEvaaatEQZpFjM4okBq9seqQ96guGCxXpzAWjZVnAYdTf6aMWKSMOQm01JtCMY/iXqkxxJ6oWnKNWrKN5epqRsu1L0ZhqUjqepTeG5Lt+j4tvtAG4n44mjLlxSJlzEmgKTi+1whIe5xYhr4e0eC1gtDUq2tKRS4PjLw6kZ81RVslrdbTSIpVhEz3MQXIczTtp03BbQhra90oNsA1ZrWxSBlzklAY1Ey2Un+on94UwhDEvvp58whpQY7vmJRrMoUHRLcJRkVtsl099hihqVBSiFSYKHiMmnS2FGlHEDY7T5iyYpEy5hTQERgUBq3wG0O+RHywvm+q/p7uE1xL4nXUExCI1YHqE5gKSlqAkfZXzSfnzSMvatXkWGPKhEXKmCXClB0fvcj/wFOkgOhM3ocQ0XTJ+Vo0MV+/Tq+cs5h3n1btqeBAjq/JMSpYRaXnXJsypoxYpIw5SSgSOuBwI8LaU5ccV0PoiZpEWIfiWhELItSxHMhHQfwcPhetWVHgNC3I6Iyfr+tVLDPX8nmtMPS4DlNmLFLGnCRq1ErasLDCj+tSY/X3NJll2o7HakqPIlFUgQfkLZRS9/I03cd70PEfTBuqJyBHzafXN6ZMWKSMOQWYsmOUciJ7JCAvGp3yXlN3RS4RSLbxtTbm8hp6PO9NxUerA3X4ok1mTVmxSBlzClQRGnjnkC9DZ5QyjVDhp1ZI7JFSHz+KB6OqGdnOtB6Pp9jxWYVHIzmmJLm2pfeszcDclvZQGVMmLFLGLBEKEVN4RT/ycwjpPhrD6joT17N0TUrXhdKmX0ZlbPCtJsdxzQuIojSNvBM7kC/24Eh5bfZ1NGXKiEXKmCXA1BqNZlUMNK1WQxCiowiFFVq4wO0Uj07EyEfNZlmmPlV/MApSJwoKzDTyDbp6X72Ia1JTcg1W+2lvljFlwyJlzBJQi6IxBNNYmsymRrOTAEYQKgBZ1DAtD4qdFj1U6udrGTmPV4f1dMyHuqhTEHmP7NWakevw75hBbDo2pows6R9Q8/PzuOWWW7B161asW7cOb3zjG/GpT30KWZY1jsmyDLfeeivOOeccrFu3Djt37sRzzz2Xu86xY8ewe/du9Pf3o1Kp4JprrsHLL7+8PH+RMU1CiydoXaQpuxmENSkKAyMY7UvStGFRpIT68XwstnZUVESRWiEVUVRVaEyZWJJI/f7v/z7uvPNO/Mmf/Am+973v4fd///dx++2347Of/WzjmNtvvx133HEH7rrrLhw4cAC9vb3YtWsXZmZmGsfs3r0bTz/9NB588EHcf//9+OY3v4lrr712+f4qY1aY1B6pBzGtRzTa4nFA6J1aj2hHpE4Rur7F152Ijb49CJFPP+LQRW7vTt7z+nSq4NoXHTLYFEwsVKaMrMk0DDoB733vezE4OIg/+7M/a2y78sorsW7dOnzpS19ClmXYvHkzPvaxj+G3fuu3AADj4+MYHBzE3Xffjauuugrf+973sG3bNjz22GPYvn07AOCBBx7Ae97zHvzkJz/B5s2bT3gfExMTGBgYwGY4l26aD9NqPQDegJDOqwA4DOAJ5I1aKwDOA/AziGnBaYQ04CSijx+jngrya1gdyFf3MdKCPCu0VmKqMG3UZcpvvn4/Q/XnJwA8A5vMmuZRA/Aigkb09/cvetySfuMvvfRS7Nu3Dz/4wQ8AAN/5znfwyCOP4N3vfjcA4Ic//CFGRkawc+fOxjkDAwPYsWMH9u/fDwDYv38/KpVKQ6AAYOfOnWhra8OBAwcKP3d2dhYTExO5hzGrCSMpXSNihKJwjhTq+ysIruMVBHHoQYyOuE0fvfLgMRUEIdtYv9b6+jNf8zr9iK7oGkF1yWf24PhpRGNWmyUVTtx0002YmJjA+eefj/b2dszPz+O2227D7t27AQAjIyMAgMHBwdx5g4ODjX0jIyPYtGlT/ibWrsX69esbx6Ts3bsXn/jEJ5Zyq8asOPMIAwknEVNnRSI1hWgkywq8PuSn7FJA0pEc7JnSpl+tJKSnH2Rf6n6uMH3Ia6f7jCkbS4qkvvKVr+Dee+/FfffdhyeeeAL33HMP/uAP/gD33HPPSt0fAODmm2/G+Ph443H48OEV/TxjTgQdG1hSzjQZ13+Ilp3P1fczktG1IR2xsRgqUB0oPl9tl1K7JT5UTNN7NaZsLCmSuvHGG3HTTTfhqquuAgBceOGF+PGPf4y9e/fi6quvxtDQEABgdHQU55xzTuO80dFRvOUtbwEADA0N4ciRI7nrvvLKKzh27Fjj/JSuri50dXUV7jNmNVEvPBUE/cFnyq+KKA69CJV/qXcez1eHcy2mmE+O1ShKK/s6k/OJOqIzotIpvcaUjSVFUtPT02hry5/S3t6OWi0UwG7duhVDQ0PYt29fY//ExAQOHDiA4eFhAMDw8DDGxsZw8ODBxjEPPfQQarUaduzYccp/iDHNQt3JWT7OMvMimPIbqz+rsGlf1RxiSfoc8mPk5xCLJhjBqQMFy9Z5rKYS9dqKnm9rJFNWlhRJ/Yt/8S9w2223YcuWLfjZn/1Z/O3f/i3+8A//EL/2a78GAFizZg2uv/56/N7v/R7OO+88bN26Fbfccgs2b96M973vfQCAN73pTXjXu96FD37wg7jrrrtQrVZx3XXX4aqrrjqpyj5jygDFRKvvtK9Jj2Nj7zGENSx661HYtCcKiA4QjHCm6udrL5Q6mwP5iIxNw1yzapfrpfdPr8CiSkFjysCSROqzn/0sbrnlFvzGb/wGjhw5gs2bN+Pf/bt/h1tvvbVxzMc//nFMTU3h2muvxdjYGN7xjnfggQceQHd3tMC89957cd111+Hyyy9HW1sbrrzyStxxxx3L91cZ0wRSE1ggRkYKI5xpxLUr9k3N1rfrIEOuXekQRYpUmlqkuHTIM++HgxR1HUv9/uZlG/G4DlM2ltQnVRbcJ2XKAp3GWbjA6EjFiqM8BgG8FbEibxSht4pi0YlQRj6EWJ0HBJ+/o4jpOY2oVHS0sILi1SPXLlpz6qtvHwXwHELjsTHN4GT7pOzdZ8xpoOtIaVSSHjeGIDb08ptD7LNqR+yZSiMcXWPiY16eiZa4a7TFdJ66WvC66qCuc62MKQsWKWNOE12LSteXuJ/Rja4VdSf7OaSwW97THDYd5ZE+q1cfff6A2F8Fea+Vg6g/dyFW+xlTJixSxiwTtePsU68/HteNIAxqOsvUHNeMOJ6ekZSWpzPa0qq8tJG3W15T7PR+UyNaY8qGRcqYZUALGo6XLqPYANH/D/KeVkVpSTjL0bn+lUZRJI2UmOqjYOnMqhnEiI6jQ4wpGxYpY5aRE63nzCL2O3UgP8tJXcw1ZUfXitQpXcvUGZ3pCJC0UVidKJBc60RuF8asFhYpY5qEWiSpiSwFhmavKXSHYCTFbSpSeiw/K70Gj9dSdmPKjkXKmCZBkWJFHxBESgsYupNzGOVwTYloqblW5TEympHt6YwrHbQIxPUwXe8ypiw4DW1ME9A1pFnEpl6dTdUlx+h03nTdCTh+NDQvxwALU4eptRILKOyOacqIIyljmgRTbWqJBOSLHbhfe69UVOjNp9dMoyy1SyLqNchoTqcFG1NWLFLGNBFGP5wxlc6PYkpQ+60oLPpAckw6noPVeppOpBs7r0EhJMcroTdmtbBIGdMk2PdELz5aELGRls4SLBNn0y+P1whI04FA3vsPiEKm40HoHahOFRSs1L3CmLJgkTKmSejsJ47u6EAoOacJbboexVTfJKIbuoqKrjtpY65GYYyyeK46VGgKcQYWKlM+LFLGNJkq4tj5XuTtkVR80miHkdAsYsGDCh+wMHWo4jeNuJ6ljb6pMBpTJlzdZ0wT0So/DkPUCGYxiyItE1+KjZEOWCwiLTl3Q68pG46kjGkyXJtiRFVDvsKPUIzoRMFzGQExVUe0p4rX1EdaGEGLpU441WfKi0XKmFWCosB1Kd3GtahuxHEgFC2KU1rwQJHSNF46R4rbOeOK86Sc6jNlxSJlzCqhwpDaHfE1t3NUByMrlqqzXJ3nUJRmkmtQ5GYRRYpmtnquMWXDImVMk1G3dBUplqHXkHcr54BE0p6co3QhCpNO7FXLJEZYfcjPqQIWphyNWW0sUsasIlwn0rScigRTd51Y6IDOHiogvw6lYqSVfrruRSum7uR6HcgLojGrjUXKmFWA6TdW+c3Jdi1FTz38FFb8AflBiEUTfLUikGLWKcd0IoqWiyhMmbBIGbOKaMMuRYMDDmn8OifH8RwlHY7IyKgoktKIS/tPtJLQKT9TJixSxqwSNJzltF4+s3IPiBHUJGJqcA75ERwUI630m09eQ47Xggzu5/qVOqYbUwYsUsasInSCGENeZOgqQfGZRD4NqEKTDkDUnqiiwYgK92lEZ6NZUyYsUsasAtoPNQngKPJiwllPQBCsCUQROZFIdSMvUjxGq/0YwemQRHVHN6YsWKSMWUVojXS0/r4Xsa9ptr5tpv46Ha+hAgR5PS3b0kZeHelRRRQ4zreyG7opGxYpY1aJNJpiZR6FpU2eKVxct0qLIlSU0ghJp/LqsYzUOpEfAWJMmbBIGbOKUDjocl5BvsoO8qx+f2lJuhZJsLcqda9IoSAxiuJ1jSkTFiljSgBHalQRI6c0sgLyab/55Pw2LKzk02gtFaC0UMPrUaaMWKSMWWW0WZfRjYoUo6NuxLHwqQgpGlVpzxNL3vU4fp7XokxZsUgZs8qk4zdmEF3RGVXRVBbIi1pNrqFRFCMrbQBOPQDV4NYCZcqKRcqYVYYRTQfiiHiuSenU3lRUFrNLSiMoC5FpZSxSxpQERlJjWOitByxsuD3exF2cYJ8xrYJFypgSoNN6J5GfA0XT12mESGsOJ3Yqt0CZVwsWKWNKQCoqNcRUXy+COI0hCJV7mcyZhEXKmJKQVuExWmIUNQaXiZszD4uUMSViXh4c19GNEElNwwJlzjwsUsaUEIrRFKIjhQXKnIl4dIwxJYVl5lrNZ8yZhiMpY0oMp/Iac6ZikTKm5FikzJmM033GGGNKi0XKGGNMabFIGWOMKS0WKWOMMaXFImWMMaa0WKSMMcaUFouUMcaY0mKRMsYYU1osUsYYY0qLRcoYY0xpsUgZY4wpLRYpY4wxpcUiZYwxprRYpIwxxpQWi5QxxpjSYpEyxhhTWixSxhhjSotFyhhjTGmxSBljjCktFiljjDGlxSJljDGmtFikjDHGlBaLlDHGmKbTfpLHWaSMMcY0hXacvDiRtStxI8YYY0zK/Cmc05IilWUZAKC2yvdhjDHm5NEoir/f/D1fjJYUqZdeegkAMLLK92GMMeb0mJycxMDAwKL7W1Kk1q9fDwA4dOjQcf+4M52JiQmce+65OHz4MPr7+1f7dkqLv6eTw9/TyeHv6eTIsgyTk5PYvHnzcY9rSZFqawv1HgMDA/6P4CTo7+/393QS+Hs6Ofw9nRz+nk7MyQQZru4zxhhTWixSxhhjSktLilRXVxd+93d/F11dXat9K6XG39PJ4e/p5PD3dHL4e1pe1mQnqv8zxhhjVomWjKSMMcacGVikjDHGlBaLlDHGmNJikTLGGFNaLFLGGGNKS0uK1Oc+9zm84Q1vQHd3N3bs2IFHH310tW+paezduxeXXHIJ+vr6sGnTJrzvfe/Ds88+mztmZmYGe/bswYYNG3DWWWfhyiuvxOjoaO6YQ4cO4YorrkBPTw82bdqEG2+8Ea+88koz/5Sm8pnPfAZr1qzB9ddf39jm7ynwwgsv4Jd/+ZexYcMGrFu3DhdeeCEef/zxxv4sy3DrrbfinHPOwbp167Bz504899xzuWscO3YMu3fvRn9/PyqVCq655hq8/PLLzf5TVoz5+Xnccsst2Lp1K9atW4c3vvGN+NSnPpUzR/X3tEJkLcaXv/zlrLOzM/uv//W/Zk8//XT2wQ9+MKtUKtno6Ohq31pT2LVrV/bFL34x++53v5s9+eST2Xve855sy5Yt2csvv9w45td//dezc889N9u3b1/2+OOPZ29/+9uzSy+9tLH/lVdeyS644IJs586d2d/+7d9mf/VXf5WdffbZ2c0337waf9KK8+ijj2ZveMMbsp/7uZ/LPvKRjzS2+3vKsmPHjmWvf/3rs1/5lV/JDhw4kD3//PPZX//1X2d/93d/1zjmM5/5TDYwMJD9j//xP7LvfOc72b/8l/8y27p1a/bTn/60ccy73vWu7M1vfnP27W9/O/ubv/mb7B/9o3+U/dIv/dJq/Ekrwm233ZZt2LAhu//++7Mf/vCH2Ve/+tXsrLPOyv7zf/7PjWP8Pa0MLSdSb3vb27I9e/Y03s/Pz2ebN2/O9u7du4p3tXocOXIkA5A9/PDDWZZl2djYWNbR0ZF99atfbRzzve99LwOQ7d+/P8uyLPurv/qrrK2tLRsZGWkcc+edd2b9/f3Z7Oxsc/+AFWZycjI777zzsgcffDD7+Z//+YZI+XsK/PZv/3b2jne8Y9H9tVotGxoayv7jf/yPjW1jY2NZV1dX9t/+23/LsizLnnnmmQxA9thjjzWO+cY3vpGtWbMme+GFF1bu5pvIFVdckf3ar/1abtv73//+bPfu3VmW+XtaSVoq3Tc3N4eDBw9i586djW1tbW3YuXMn9u/fv4p3tnqMj48DiM7wBw8eRLVazX1H559/PrZs2dL4jvbv348LL7wQg4ODjWN27dqFiYkJPP300028+5Vnz549uOKKK3LfB+DvifzlX/4ltm/fjl/8xV/Epk2bcNFFF+ELX/hCY/8Pf/hDjIyM5L6ngYEB7NixI/c9VSoVbN++vXHMzp070dbWhgMHDjTvj1lBLr30Uuzbtw8/+MEPAADf+c538Mgjj+Dd7343AH9PK0lLuaD/wz/8A+bn53M/GgAwODiI73//+6t0V6tHrVbD9ddfj8suuwwXXHABAGBkZASdnZ2oVCq5YwcHBzEyMtI4pug75L5XC1/+8pfxxBNP4LHHHluwz99T4Pnnn8edd96JG264Af/+3/97PPbYY/jN3/xNdHZ24uqrr278nUXfg35PmzZtyu1fu3Yt1q9f/6r5nm666SZMTEzg/PPPR3t7O+bn53Hbbbdh9+7dAODvaQVpKZEyefbs2YPvfve7eOSRR1b7VkrH4cOH8ZGPfAQPPvgguru7V/t2SkutVsP27dvx6U9/GgBw0UUX4bvf/S7uuusuXH311at8d+XhK1/5Cu69917cd999+Nmf/Vk8+eSTuP7667F582Z/TytMS6X7zj77bLS3ty+owBodHcXQ0NAq3dXqcN111+H+++/H//pf/wuve93rGtuHhoYwNzeHsbGx3PH6HQ0NDRV+h9z3auDgwYM4cuQI3vrWt2Lt2rVYu3YtHn74Ydxxxx1Yu3YtBgcH/T0BOOecc7Bt27bctje96U04dOgQgPh3Hu//uaGhIRw5ciS3/5VXXsGxY8deNd/TjTfeiJtuuglXXXUVLrzwQnzgAx/ARz/6UezduxeAv6eVpKVEqrOzExdffDH27dvX2Far1bBv3z4MDw+v4p01jyzLcN111+FrX/saHnroIWzdujW3/+KLL0ZHR0fuO3r22Wdx6NChxnc0PDyMp556Kvc/zIMPPoj+/v4FP1ityuWXX46nnnoKTz75ZOOxfft27N69u/Ha3xNw2WWXLWhh+MEPfoDXv/71AICtW7diaGgo9z1NTEzgwIEDue9pbGwMBw8ebBzz0EMPoVarYceOHU34K1ae6enpxrBV0t7ejlqtBsDf04qy2pUbS+XLX/5y1tXVld19993ZM888k1177bVZpVLJVWC9mvnQhz6UDQwMZP/7f//v7O///u8bj+np6cYxv/7rv55t2bIle+ihh7LHH388Gx4ezoaHhxv7WVr9zne+M3vyySezBx54INu4ceOrqrS6CK3uyzJ/T1kWyvPXrl2b3Xbbbdlzzz2X3XvvvVlPT0/2pS99qXHMZz7zmaxSqWR/8Rd/kf3f//t/s3/1r/5VYWn1RRddlB04cCB75JFHsvPOO+9VVVp99dVXZ6997WsbJej//b//9+zss8/OPv7xjzeO8fe0MrScSGVZln32s5/NtmzZknV2dmZve9vbsm9/+9urfUtNA0Dh44tf/GLjmJ/+9KfZb/zGb2Svec1rsp6enuwXfuEXsr//+7/PXedHP/pR9u53vztbt25ddvbZZ2cf+9jHsmq12uS/prmkIuXvKfD1r389u+CCC7Kurq7s/PPPzz7/+c/n9tdqteyWW27JBgcHs66uruzyyy/Pnn322dwxL730UvZLv/RL2VlnnZX19/dnv/qrv5pNTk42889YUSYmJrKPfOQj2ZYtW7Lu7u7sZ37mZ7L/8B/+Q64Vwd/TyuB5UsYYY0pLS61JGWOMObOwSBljjCktFiljjDGlxSJljDGmtFikjDHGlBaLlDHGmNJikTLGGFNaLFLGGGNKi0XKGGNMabFIGWOMKS0WKWOMMaXl/wceiCWFw3Du0gAAAABJRU5ErkJggg=="},"metadata":{}}]},{"cell_type":"code","source":"# computation time on cpu+gpu\nimport time\nimport torch\ni=15\nstart_time = time.perf_counter()\npyrnet_pred_gpu, autonet_pred_gpu = model(directory, files, i, device1, device2)\n\nelapsed_time = (time.perf_counter() - start_time)\nprint(f\"Model inference time (might include non-GPU operations): {elapsed_time} seconds\")","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:57:50.192958Z","iopub.execute_input":"2024-08-09T07:57:50.193243Z","iopub.status.idle":"2024-08-09T07:57:50.271038Z","shell.execute_reply.started":"2024-08-09T07:57:50.193219Z","shell.execute_reply":"2024-08-09T07:57:50.270160Z"},"trusted":true},"execution_count":45,"outputs":[{"name":"stdout","text":"0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15 (current)\ntorch.Size([1, 1, 1000, 1000])\ntorch.Size([1, 1, 1000, 1000])\nModel inference time (might include non-GPU operations): 0.07340651900017292 seconds\n","output_type":"stream"}]},{"cell_type":"code","source":"#save trained model's parameters\ntorch.save(aPPN_gpu.state_dict(), \"racetrained-PPN-recnet.pth\")\ntorch.save(model.state_dict(), \"racetrained-PPN-model.pth\")","metadata":{"execution":{"iopub.status.busy":"2024-08-09T07:57:50.271988Z","iopub.execute_input":"2024-08-09T07:57:50.272252Z","iopub.status.idle":"2024-08-09T07:57:51.250138Z","shell.execute_reply.started":"2024-08-09T07:57:50.272229Z","shell.execute_reply":"2024-08-09T07:57:51.249048Z"},"trusted":true},"execution_count":46,"outputs":[]}]}