stereo_cmp.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "xFormers not available\n",
      "xFormers not available\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import os\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from pathlib import Path\n",
    "import cv2\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from mono.mono_head import InferDAM\n",
    "from stereo.stereo_head import InferCREStereo\n",
    "\n",
    "import torchvision.models as models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "gt_dir='/home/william/extdisk/data/realsense-D455_depth_image/sample/depth'\n",
    "raft_dir='/home/william/extdisk/data/realsense-D455_depth_image/sample/raft'\n",
    "gms_dir='/home/william/extdisk/data/realsense-D455_depth_image/sample/gmstereo'\n",
    "cres_dir='/home/william/extdisk/data/realsense-D455_depth_image/sample/crestero'\n",
    "cmp_dir='/home/william/extdisk/data/realsense-D455_depth_image/sample/research'\n",
    "left_dir='/home/william/extdisk/data/realsense-D455_depth_image/sample/infra1'\n",
    "right_dir='/home/william/extdisk/data/realsense-D455_depth_image/sample/infra2'\n",
    "mono_dir='/home/william/extdisk/data/realsense-D455_depth_image/sample/damv2'\n",
    "focal = 390.81134033203125\n",
    "baseline = 94.994\n",
    "cx = 320.83\n",
    "cy = 245.31\n",
    "# os.makedirs(cmp_dir, exist_ok=True)\n",
    "# os.makedirs(mono_dir, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_gts = sorted(Path('/home/william/extdisk/data/realsense-D455_depth_image/sample/depth').glob('*.png'))\n",
    "f_rafts = sorted(Path(\"/home/william/extdisk/data/realsense-D455_depth_image/sample/raft\").glob('*.npy'))\n",
    "f_gms = sorted(Path(\"/home/william/extdisk/data/realsense-D455_depth_image/sample/gmstereo\").glob('*_disp.pfm'))\n",
    "f_cres = sorted(Path(\"/home/william/extdisk/data/realsense-D455_depth_image/sample/crestereo\").glob('*.npy'))\n",
    "f_left = sorted(Path(left_dir).glob('*.png'))\n",
    "f_right = sorted(Path(right_dir).glob('*.png'))\n",
    "f_mono = sorted(Path(mono_dir).glob('*.npy'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "\n",
    "def read_pfm(file):\n",
    "    file = open(file, 'rb')\n",
    "\n",
    "    color = None\n",
    "    width = None\n",
    "    height = None\n",
    "    scale = None\n",
    "    endian = None\n",
    "\n",
    "    header = file.readline().rstrip()\n",
    "    if header.decode(\"ascii\") == 'PF':\n",
    "        color = True\n",
    "    elif header.decode(\"ascii\") == 'Pf':\n",
    "        color = False\n",
    "    else:\n",
    "        raise Exception('Not a PFM file.')\n",
    "\n",
    "    dim_match = re.match(r'^(\\d+)\\s(\\d+)\\s$', file.readline().decode(\"ascii\"))\n",
    "    if dim_match:\n",
    "        width, height = list(map(int, dim_match.groups()))\n",
    "    else:\n",
    "        raise Exception('Malformed PFM header.')\n",
    "\n",
    "    scale = float(file.readline().decode(\"ascii\").rstrip())\n",
    "    if scale < 0:  # little-endian\n",
    "        endian = '<'\n",
    "        scale = -scale\n",
    "    else:\n",
    "        endian = '>'  # big-endian\n",
    "\n",
    "    data = np.fromfile(file, endian + 'f')\n",
    "    shape = (height, width, 3) if color else (height, width)\n",
    "\n",
    "    data = np.reshape(data, shape)\n",
    "    data = np.flipud(data)\n",
    "    return data*scale\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mono.depth_anything_v2.dinov2 import DINOv2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "import math\n",
    "\n",
    "class DinoV2FeatureExtractor(nn.Module):\n",
    "    def __init__(self, dino_model):\n",
    "        super().__init__()\n",
    "        self.dino_model = dino_model\n",
    "        for param in self.parameters():\n",
    "            param.requires_grad = False\n",
    "    def forward(self, x):\n",
    "        f = self.dino_model.get_intermediate_layers(x, n=1)[0]  \n",
    "        b, n, d = f.shape\n",
    "        # Remove CLS token\n",
    "        p = f[:, 1:, :]  \n",
    "        num_patches = p.shape[1]  # N - 1\n",
    "        s = int(math.sqrt(num_patches))\n",
    "        if s * s != num_patches:\n",
    "            raise ValueError(\n",
    "                f\"Number of patch tokens ({num_patches}) is not a perfect square.\"\n",
    "                f\" Image size or patch size might be incompatible.\"\n",
    "            )\n",
    "        # s = int(math.sqrt(n - 1))\n",
    "        p = p.reshape(b, s, s, d).permute(0, 3, 1, 2)\n",
    "        return p\n",
    "\n",
    "class DisparityRefinementNet(nn.Module):\n",
    "    def __init__(self, in_channels=2, feat_channels=384, out_channels=1):\n",
    "        super().__init__()\n",
    "        self.conv1 = nn.Sequential(\n",
    "            nn.Conv2d(in_channels + feat_channels, 64, 3, 1, 1),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(64, 64, 3, 1, 1),\n",
    "            nn.ReLU(True)\n",
    "        )\n",
    "        self.conv2 = nn.Sequential(\n",
    "            nn.Conv2d(64, 64, 3, 1, 1),\n",
    "            nn.ReLU(True),\n",
    "            nn.Conv2d(64, out_channels, 3, 1, 1)\n",
    "        )\n",
    "    def forward(self, dm, ds, dino_feat):\n",
    "        b, _, h, w = dm.shape\n",
    "        c = torch.cat([dm, ds], dim=1)\n",
    "        u = F.interpolate(dino_feat, size=(h, w), mode='bilinear', align_corners=False)\n",
    "        x = torch.cat([c, u], dim=1)\n",
    "        x = self.conv1(x)\n",
    "        x = self.conv2(x)\n",
    "        return x\n",
    "\n",
    "def warp_right_to_left(right_img, disp):\n",
    "    b, c, h, w = right_img.shape\n",
    "    y = torch.linspace(0, h - 1, h, device=right_img.device).view(1, h, 1).expand(b, h, w)\n",
    "    x = torch.linspace(0, w - 1, w, device=right_img.device).view(1, 1, w).expand(b, h, w)\n",
    "    x_warp = x - disp[:, 0, :, :]\n",
    "    grid_x = 2.0 * x_warp / (w - 1) - 1.0\n",
    "    grid_y = 2.0 * y / (h - 1) - 1.0\n",
    "    grid = torch.stack([grid_x, grid_y], dim=3)\n",
    "    return F.grid_sample(right_img, grid, mode='bilinear', padding_mode='border', align_corners=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "from torchvision import transforms\n",
    "import ast\n",
    "import re\n",
    "from PIL import Image\n",
    "\n",
    "class Middlebury2014(Dataset):\n",
    "    def __init__(self, data_list_path):\n",
    "        with open(data_list_path, \"r\") as f:\n",
    "            self.data_list = [line.strip() for line in f if line.strip()]\n",
    "        self.data_list.sort()\n",
    "        self.l_name = \"im0.png\"\n",
    "        self.r_name = \"im1.png\"\n",
    "        self.l_disp_name = \"disp0.pfm\"\n",
    "        self.r_disp_name = \"disp1.pfm\"\n",
    "\n",
    "        self.img_h = 518\n",
    "        self.img_w = 518\n",
    "\n",
    "        self.transform = transforms.Compose([\n",
    "            transforms.Resize((self.img_h, self.img_w)),\n",
    "            transforms.ToTensor()\n",
    "        ])\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data_list)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        scene_dir = self.data_list[index]\n",
    "        left_img_path = os.path.join(scene_dir, self.l_name)\n",
    "        right_img_path = os.path.join(scene_dir, self.r_name)\n",
    "        left_disp_path = os.path.join(scene_dir, self.l_disp_name)\n",
    "        right_disp_path = os.path.join(scene_dir, self.r_disp_name)\n",
    "\n",
    "        left_img_bgr = cv2.imread(left_img_path, cv2.IMREAD_ANYCOLOR)\n",
    "        right_img_bgr = cv2.imread(right_img_path, cv2.IMREAD_ANYCOLOR)\n",
    "\n",
    "        left_img_rgb = cv2.cvtColor(left_img_bgr, cv2.COLOR_BGR2RGB)\n",
    "        right_img_rgb = cv2.cvtColor(right_img_bgr, cv2.COLOR_BGR2RGB)\n",
    "\n",
    "        left_disp = read_pfm(left_disp_path)\n",
    "        right_disp = read_pfm(right_disp_path)\n",
    "\n",
    "        left_img_pil = Image.fromarray(left_img_rgb)\n",
    "        right_img_pil = Image.fromarray(right_img_rgb)\n",
    "\n",
    "        left_img_tensor = self.transform(left_img_pil)\n",
    "        right_img_tensor = self.transform(right_img_pil)\n",
    "\n",
    "        left_disp_tensor = torch.from_numpy(left_disp).unsqueeze(0).float()\n",
    "        right_disp_tensor = torch.from_numpy(right_disp).unsqueeze(0).float()\n",
    "\n",
    "        sample = {\n",
    "            \"left_image\": left_img_tensor,   # (3, 518, 518)\n",
    "            \"right_image\": right_img_tensor, # (3, 518, 518)\n",
    "            \"left_disp\": left_disp_tensor,   # (1, H, W)\n",
    "            \"right_disp\": right_disp_tensor  # (1, H, W)\n",
    "        }\n",
    "\n",
    "        return sample\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "middlebury_data_list_path=\"/home/william/extdisk/data/middlebury/middlebury2014/middlebury2014_dataset.txt\"\n",
    "m2014_dataset = Middlebury2014(middlebury_data_list_path)\n",
    "dino_model = DINOv2('vits')\n",
    "mono_model = InferDAM()\n",
    "mono_model.initialize(model_path='/home/william/extdisk/checkpoints/depth-anything/depth_anything_v2_vits.pth', encoder='vits')\n",
    "\n",
    "stereo_model = InferCREStereo()\n",
    "stereo_model.initialize(model_path='/home/william/extdisk/checkpoints/CREStereo/crestereo_eth3d.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_one_epoch(dino_extractor, mono_net, stereo_net, refine_net, dataloader, optimizer, alpha=0.1, device=\"cuda\"):\n",
    "    dino_extractor.eval()\n",
    "    refine_net.train()\n",
    "    s = 0\n",
    "    for batch in dataloader:\n",
    "        l = batch[\"left_image\"].to(device)\n",
    "        r = batch[\"right_image\"].to(device)\n",
    "        with torch.no_grad():\n",
    "            print(f\"l shape is {l.shape}\")\n",
    "            fl = dino_extractor(l)\n",
    "            dm = mono_net.predict(l)\n",
    "            ds = stereo_net.predict(l, r)\n",
    "            gt = ds\n",
    "        pred = refine_net(dm, ds, fl)\n",
    "        loss_gt = F.l1_loss(pred, gt)\n",
    "        warped_r = warp_right_to_left(r, pred)\n",
    "        loss_photo = F.l1_loss(l, warped_r)\n",
    "        loss = loss_gt + alpha * loss_photo\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        s += loss.item()\n",
    "    return s / len(dataloader)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "dino_extractor = DinoV2FeatureExtractor(dino_model).cuda()\n",
    "refine_net = DisparityRefinementNet(in_channels=2, feat_channels=768, out_channels=1).cuda()\n",
    "dataset = m2014_dataset\n",
    "dataloader = DataLoader(dataset, batch_size=1, shuffle=True, pin_memory=True)\n",
    "optimizer = optim.AdamW(refine_net.parameters(), lr=1e-4, weight_decay=0.01)\n",
    "\n",
    "for e in range(10):\n",
    "    l = train_one_epoch(dino_extractor, mono_model, stereo_model, refine_net, dataloader, optimizer, alpha=0.1, device=\"cuda\")\n",
    "    print(e, l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class ChannelAttention(nn.Module):\n",
    "    def __init__(self, in_channels, reduction_ratio=16):\n",
    "        super(ChannelAttention, self).__init__()\n",
    "        self.fc1 = nn.Conv2d(in_channels, in_channels // reduction_ratio, kernel_size=1)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.fc2 = nn.Conv2d(in_channels // reduction_ratio, in_channels, kernel_size=1)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        avg_pool = torch.mean(x, dim=(2, 3), keepdim=True)\n",
    "        channel_attention = self.fc2(self.relu(self.fc1(avg_pool)))\n",
    "        return x * self.sigmoid(channel_attention)\n",
    "    \n",
    "\n",
    "class SpatialAttention(nn.Module):\n",
    "    def __init__(self, in_channels):\n",
    "        super(SpatialAttention, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channels, 1, kernel_size=7, stride=1, padding=3)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, x):\n",
    "        attention_map = self.conv1(x)\n",
    "        attention_map = self.sigmoid(attention_map)\n",
    "        return x * attention_map\n",
    "    \n",
    "\n",
    "class FusionNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(FusionNet, self).__init__()\n",
    "        # Encoder\n",
    "        self.encoder_dual = nn.Sequential(\n",
    "            nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        self.encoder_mono = nn.Sequential(\n",
    "            nn.Conv2d(1, 64, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        # Fusion Module\n",
    "        self.fusion = nn.Sequential(\n",
    "            nn.Conv2d(256*2, 128*2, kernel_size=3, stride=1, padding=1), nn.ReLU(),\n",
    "            nn.Dropout(p=0.3) \n",
    "        )\n",
    "        # Spatial Attention\n",
    "        self.spatial_attention = SpatialAttention(128*2)\n",
    "        self.channel_attention = ChannelAttention(128*2)\n",
    "        # Decoder\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1),  # Try kernel_size=3\n",
    "            nn.ReLU(),\n",
    "            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),   # Adjust kernel_size, padding\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(64, 1, kernel_size=3, stride=1, padding=1),\n",
    "        )\n",
    "\n",
    "        self.encoder_dual.to(\"cuda\")\n",
    "        self.encoder_mono.to(\"cuda\")\n",
    "        self.fusion.to(\"cuda\")\n",
    "        self.spatial_attention.to(\"cuda\")\n",
    "        self.channel_attention.to(\"cuda\")\n",
    "        self.decoder.to(\"cuda\")\n",
    "\n",
    "    def forward(self, disparity_dual, disparity_mono):\n",
    "        # Extract features\n",
    "        feat_dual = self.encoder_dual(disparity_dual)\n",
    "        feat_mono = self.encoder_mono(disparity_mono)\n",
    "        # Fusion\n",
    "        feat_fused = torch.cat([feat_dual, feat_mono], dim=1)\n",
    "        feat_fused = self.fusion(feat_fused)\n",
    "        # Apply Spatial Attention\n",
    "        feat_fused = self.spatial_attention(feat_fused)\n",
    "        feat_fused = self.channel_attention(feat_fused)\n",
    "        # Decode\n",
    "        output = self.decoder(feat_fused)\n",
    "        return output\n",
    "\n",
    "# Loss functions\n",
    "def edge_loss(output, target):\n",
    "    sobel_x = torch.tensor([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=torch.float32).view(1, 1, 3, 3).to('cuda')\n",
    "    sobel_y = torch.tensor([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=torch.float32).view(1, 1, 3, 3).to('cuda')\n",
    "    edge_output = torch.sqrt(F.conv2d(output, sobel_x)**2 + F.conv2d(output, sobel_y)**2)\n",
    "    edge_target = torch.sqrt(F.conv2d(target, sobel_x)**2 + F.conv2d(target, sobel_y)**2)\n",
    "    return F.l1_loss(edge_output, edge_target)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision.models as models\n",
    "\n",
    "class ResNetFusionNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(ResNetFusionNet, self).__init__()\n",
    "        # 使用 ResNet18 作为 Encoder\n",
    "        self.encoder_dual = models.resnet18(pretrained=True)\n",
    "        self.encoder_mono = models.resnet18(pretrained=True)\n",
    "\n",
    "        for encoder in [self.encoder_dual, self.encoder_mono]:\n",
    "            original_weight = encoder.conv1.weight\n",
    "            new_conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)\n",
    "            new_conv1.weight = nn.Parameter(original_weight.mean(dim=1, keepdim=True))\n",
    "            encoder.conv1 = new_conv1\n",
    "        \n",
    "\n",
    "        self.encoder_dual = nn.Sequential(*list(self.encoder_dual.children())[:-2])\n",
    "        self.encoder_mono = nn.Sequential(*list(self.encoder_mono.children())[:-2])\n",
    "        \n",
    "        # Fusion Module\n",
    "        self.fusion = nn.Sequential(\n",
    "            nn.Conv2d(1024, 512, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        # Decoder\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.ConvTranspose2d(512, 256, kernel_size=4, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(64, 1, kernel_size=3, stride=1, padding=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, disparity_dual, disparity_mono):\n",
    "        # Extract features\n",
    "        feat_dual = self.encoder_dual(disparity_dual)\n",
    "        feat_mono = self.encoder_mono(disparity_mono)\n",
    "        \n",
    "        # Fusion\n",
    "        feat_fused = torch.cat([feat_dual, feat_mono], dim=1)\n",
    "        feat_fused = self.fusion(feat_fused)\n",
    "        \n",
    "        # Decode\n",
    "        output = self.decoder(feat_fused)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision.models as models\n",
    "\n",
    "class MobileNetV3FusionNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(MobileNetV3FusionNet, self).__init__()\n",
    "        # 使用 MobileNetV3 作为 Encoder\n",
    "        self.encoder_dual = models.mobilenet_v3_small(pretrained=True)\n",
    "        self.encoder_mono = models.mobilenet_v3_small(pretrained=True)\n",
    "\n",
    "        for encoder in [self.encoder_dual, self.encoder_mono]:\n",
    "            original_weight = encoder.features[0][0].weight\n",
    "            new_conv = nn.Conv2d(1, 16, kernel_size=3, stride=2, padding=1, bias=False)\n",
    "            new_conv.weight = nn.Parameter(original_weight.mean(dim=1, keepdim=True))\n",
    "            encoder.features[0][0] = new_conv\n",
    "        \n",
    "        self.encoder_dual = nn.Sequential(*list(self.encoder_dual.children())[:-1])\n",
    "        self.encoder_mono = nn.Sequential(*list(self.encoder_mono.children())[:-1])\n",
    "        \n",
    "        # Fusion Module\n",
    "        self.fusion = nn.Sequential(\n",
    "            nn.Conv2d(576*2, 256, kernel_size=3, stride=1, padding=1),\n",
    "            nn.ReLU()\n",
    "        )\n",
    "        \n",
    "        # Decoder\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.ConvTranspose2d(256, 128, kernel_size=4, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.ConvTranspose2d(128, 64, kernel_size=4, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.ConvTranspose2d(64, 32, kernel_size=4, stride=2, padding=1),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(32, 1, kernel_size=3, stride=1, padding=1)\n",
    "        )\n",
    "\n",
    "    def forward(self, disparity_dual, disparity_mono):\n",
    "        # Extract features\n",
    "        feat_dual = self.encoder_dual(disparity_dual)\n",
    "        feat_mono = self.encoder_mono(disparity_mono)\n",
    "        \n",
    "        # Fusion\n",
    "        feat_fused = torch.cat([feat_dual, feat_mono], dim=1)\n",
    "        feat_fused = self.fusion(feat_fused)\n",
    "        \n",
    "        # Decode\n",
    "        output = self.decoder(feat_fused)\n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def tensor_norm(t:torch.Tensor):\n",
    "    v_min = t.min()\n",
    "    v_max = t.max()\n",
    "\n",
    "    norm_t = (t-v_min)/(v_max-v_min)\n",
    "    return norm_t, v_min, v_max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training loop\n",
    "def train_one_epoch(input_stereo, input_mono, n_iters=100, device='cuda'):\n",
    "    model = FusionNet().to(device)\n",
    "    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)\n",
    "    criterion_pixel = nn.L1Loss().to(device)\n",
    "    criterion_edge = edge_loss\n",
    "\n",
    "    # stereo_norm, stereo_min, stereo_max = tensor_norm(input_stereo)\n",
    "    # mono_norm, mono_min, mono_max = tensor_norm(input_mono)\n",
    "    stereo_norm, mono_norm = input_stereo, input_mono\n",
    "\n",
    "\n",
    "    for epoch in range(n_iters):\n",
    "        optimizer.zero_grad()\n",
    "        output = model(stereo_norm, mono_norm)\n",
    "        print(f\"output shape is {output.shape}\")\n",
    "        loss_pixel = criterion_pixel(output, stereo_norm)\n",
    "        loss_edge = criterion_edge(output, mono_norm)\n",
    "        loss = loss_pixel + 0.7 * loss_edge\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        print(f'Epoch {epoch}, Total Loss: {loss:.4f}, Pixel Loss: {loss_pixel:.4f}, Edge Loss: {loss_edge:.4f}')\n",
    "    return model\n",
    "\n",
    "# Training loop\n",
    "def train_one_epoch_resnet(input_stereo, input_mono, n_iters=100, device='cuda'):\n",
    "    model = ResNetFusionNet().to(device)\n",
    "    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)\n",
    "    criterion_pixel = nn.L1Loss().to(device)\n",
    "    criterion_edge = edge_loss\n",
    "\n",
    "    orig_h, orig_w = input_stereo.shape[2:]\n",
    "    print(f\"input shape is {input_stereo.shape}\")\n",
    "    print(f\"orig_h, orig_w shape is  {orig_h}, {orig_w}\")\n",
    "    for epoch in range(n_iters):\n",
    "        optimizer.zero_grad()\n",
    "        output = model(input_stereo, input_mono)\n",
    "        output_resize = F.interpolate(output, (orig_h, orig_w), mode='bilinear', align_corners=True)\n",
    "        print(f\"output shape is {output_resize.shape}\")\n",
    "        loss_pixel = criterion_pixel(output_resize, input_stereo)\n",
    "        loss_edge = criterion_edge(output_resize, input_mono)\n",
    "        loss = loss_pixel + 0.3 * loss_edge\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        print(f'Epoch {epoch}, Total Loss: {loss:.4f}, Pixel Loss: {loss_pixel:.4f}, Edge Loss: {loss_edge:.4f}')\n",
    "    return model\n",
    "\n",
    "# Training loop\n",
    "def train_one_epoch_mbv3(input_stereo, input_mono, n_iters=100, device='cuda'):\n",
    "    model = MobileNetV3FusionNet().to(device)\n",
    "    optimizer = torch.optim.AdamW(model.parameters(), lr=1e-4)\n",
    "    criterion_pixel = nn.L1Loss().to(device)\n",
    "    criterion_edge = edge_loss\n",
    "\n",
    "    orig_h, orig_w = input_stereo.shape[2:]\n",
    "    print(f\"input shape is {input_stereo.shape}\")\n",
    "\n",
    "    for epoch in range(n_iters):\n",
    "        optimizer.zero_grad()\n",
    "        output = model(input_stereo, input_mono)\n",
    "        output_resize = F.interpolate(output, (orig_h, orig_w), mode='bilinear', align_corners=True)\n",
    "        print(f\"output shape is {output_resize.shape}\")\n",
    "        loss_pixel = criterion_pixel(output_resize, input_stereo)\n",
    "        loss_edge = criterion_edge(output_resize, input_mono)\n",
    "        loss = loss_pixel + 0.3 * loss_edge\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        print(f'Epoch {epoch}, Total Loss: {loss:.4f}, Pixel Loss: {loss_pixel:.4f}, Edge Loss: {loss_edge:.4f}')\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "cres_numpy_output = np.load(f_cres[0])\n",
    "mono_numpy_output = np.load(f_mono[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.imshow(cres_numpy_output, cmap='magma')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.imshow(mono_numpy_output, cmap='magma')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "cres_stereo_tensor = torch.from_numpy(cres_numpy_output).unsqueeze(0).unsqueeze(1)\n",
    "mono_stereo_tensor = torch.from_numpy(mono_numpy_output).unsqueeze(0).unsqueeze(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 0, Total Loss: 9.0332, Pixel Loss: 8.8888, Edge Loss: 0.2062\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 1, Total Loss: 9.0166, Pixel Loss: 8.8872, Edge Loss: 0.1849\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 2, Total Loss: 8.9956, Pixel Loss: 8.8856, Edge Loss: 0.1572\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 3, Total Loss: 8.9894, Pixel Loss: 8.8834, Edge Loss: 0.1515\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 4, Total Loss: 8.9863, Pixel Loss: 8.8788, Edge Loss: 0.1536\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 5, Total Loss: 8.9753, Pixel Loss: 8.8748, Edge Loss: 0.1436\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 6, Total Loss: 8.9707, Pixel Loss: 8.8710, Edge Loss: 0.1424\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 7, Total Loss: 8.9671, Pixel Loss: 8.8661, Edge Loss: 0.1443\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 8, Total Loss: 8.9593, Pixel Loss: 8.8590, Edge Loss: 0.1433\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 9, Total Loss: 8.9473, Pixel Loss: 8.8482, Edge Loss: 0.1416\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 10, Total Loss: 8.9335, Pixel Loss: 8.8322, Edge Loss: 0.1447\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 11, Total Loss: 8.9156, Pixel Loss: 8.8103, Edge Loss: 0.1504\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 12, Total Loss: 8.8878, Pixel Loss: 8.7821, Edge Loss: 0.1510\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 13, Total Loss: 8.8494, Pixel Loss: 8.7443, Edge Loss: 0.1501\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 14, Total Loss: 8.8002, Pixel Loss: 8.6919, Edge Loss: 0.1547\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 15, Total Loss: 8.7312, Pixel Loss: 8.6185, Edge Loss: 0.1611\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 16, Total Loss: 8.6327, Pixel Loss: 8.5156, Edge Loss: 0.1673\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 17, Total Loss: 8.4968, Pixel Loss: 8.3717, Edge Loss: 0.1788\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 18, Total Loss: 8.3141, Pixel Loss: 8.1754, Edge Loss: 0.1981\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 19, Total Loss: 8.0663, Pixel Loss: 7.9071, Edge Loss: 0.2274\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 20, Total Loss: 7.7393, Pixel Loss: 7.5479, Edge Loss: 0.2734\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 21, Total Loss: 7.3068, Pixel Loss: 7.0659, Edge Loss: 0.3442\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 22, Total Loss: 6.7411, Pixel Loss: 6.4320, Edge Loss: 0.4416\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 23, Total Loss: 5.9868, Pixel Loss: 5.5922, Edge Loss: 0.5637\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 24, Total Loss: 5.0075, Pixel Loss: 4.4940, Edge Loss: 0.7335\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 25, Total Loss: 3.7335, Pixel Loss: 3.0547, Edge Loss: 0.9698\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 26, Total Loss: 2.1589, Pixel Loss: 1.2649, Edge Loss: 1.2771\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 27, Total Loss: 3.0425, Pixel Loss: 1.8719, Edge Loss: 1.6722\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 28, Total Loss: 4.0235, Pixel Loss: 2.7328, Edge Loss: 1.8439\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 29, Total Loss: 3.7525, Pixel Loss: 2.4927, Edge Loss: 1.7996\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 30, Total Loss: 2.8566, Pixel Loss: 1.7098, Edge Loss: 1.6383\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 31, Total Loss: 1.9337, Pixel Loss: 0.9364, Edge Loss: 1.4247\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 32, Total Loss: 1.9840, Pixel Loss: 1.1223, Edge Loss: 1.2311\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 33, Total Loss: 2.4770, Pixel Loss: 1.6888, Edge Loss: 1.1259\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 34, Total Loss: 2.6894, Pixel Loss: 1.9143, Edge Loss: 1.1073\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 35, Total Loss: 2.6256, Pixel Loss: 1.8324, Edge Loss: 1.1330\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 36, Total Loss: 2.3405, Pixel Loss: 1.5089, Edge Loss: 1.1881\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 37, Total Loss: 1.8407, Pixel Loss: 0.9598, Edge Loss: 1.2584\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 38, Total Loss: 1.6890, Pixel Loss: 0.7293, Edge Loss: 1.3710\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 39, Total Loss: 2.0820, Pixel Loss: 1.0694, Edge Loss: 1.4465\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 40, Total Loss: 2.1861, Pixel Loss: 1.1467, Edge Loss: 1.4849\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 41, Total Loss: 1.9523, Pixel Loss: 0.9292, Edge Loss: 1.4615\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 42, Total Loss: 1.6416, Pixel Loss: 0.6899, Edge Loss: 1.3595\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 43, Total Loss: 1.7343, Pixel Loss: 0.8517, Edge Loss: 1.2609\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 44, Total Loss: 1.8772, Pixel Loss: 1.0325, Edge Loss: 1.2067\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 45, Total Loss: 1.8534, Pixel Loss: 1.0040, Edge Loss: 1.2134\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 46, Total Loss: 1.6927, Pixel Loss: 0.8039, Edge Loss: 1.2697\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 47, Total Loss: 1.5776, Pixel Loss: 0.6422, Edge Loss: 1.3363\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 48, Total Loss: 1.7103, Pixel Loss: 0.7447, Edge Loss: 1.3795\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 49, Total Loss: 1.7374, Pixel Loss: 0.7755, Edge Loss: 1.3742\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 50, Total Loss: 1.6157, Pixel Loss: 0.6763, Edge Loss: 1.3419\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 51, Total Loss: 1.5520, Pixel Loss: 0.6493, Edge Loss: 1.2896\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 52, Total Loss: 1.6222, Pixel Loss: 0.7460, Edge Loss: 1.2517\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 53, Total Loss: 1.6323, Pixel Loss: 0.7647, Edge Loss: 1.2394\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 54, Total Loss: 1.5654, Pixel Loss: 0.6813, Edge Loss: 1.2629\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 55, Total Loss: 1.5275, Pixel Loss: 0.6214, Edge Loss: 1.2945\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 56, Total Loss: 1.5792, Pixel Loss: 0.6549, Edge Loss: 1.3204\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 57, Total Loss: 1.5557, Pixel Loss: 0.6416, Edge Loss: 1.3059\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 58, Total Loss: 1.4926, Pixel Loss: 0.6031, Edge Loss: 1.2707\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 59, Total Loss: 1.5012, Pixel Loss: 0.6393, Edge Loss: 1.2314\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 60, Total Loss: 1.5265, Pixel Loss: 0.6650, Edge Loss: 1.2308\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 61, Total Loss: 1.5086, Pixel Loss: 0.6343, Edge Loss: 1.2490\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 62, Total Loss: 1.4840, Pixel Loss: 0.6005, Edge Loss: 1.2621\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 63, Total Loss: 1.4823, Pixel Loss: 0.6024, Edge Loss: 1.2571\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 64, Total Loss: 1.4750, Pixel Loss: 0.5932, Edge Loss: 1.2597\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 65, Total Loss: 1.4574, Pixel Loss: 0.5858, Edge Loss: 1.2452\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 66, Total Loss: 1.4665, Pixel Loss: 0.6058, Edge Loss: 1.2296\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 67, Total Loss: 1.4535, Pixel Loss: 0.6054, Edge Loss: 1.2115\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 68, Total Loss: 1.4348, Pixel Loss: 0.5829, Edge Loss: 1.2169\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 69, Total Loss: 1.4401, Pixel Loss: 0.5759, Edge Loss: 1.2347\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 70, Total Loss: 1.4309, Pixel Loss: 0.5722, Edge Loss: 1.2267\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 71, Total Loss: 1.4203, Pixel Loss: 0.5708, Edge Loss: 1.2136\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 72, Total Loss: 1.4262, Pixel Loss: 0.5805, Edge Loss: 1.2082\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 73, Total Loss: 1.4199, Pixel Loss: 0.5770, Edge Loss: 1.2041\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 74, Total Loss: 1.4065, Pixel Loss: 0.5648, Edge Loss: 1.2025\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 75, Total Loss: 1.4020, Pixel Loss: 0.5612, Edge Loss: 1.2011\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 76, Total Loss: 1.4027, Pixel Loss: 0.5577, Edge Loss: 1.2072\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 77, Total Loss: 1.3949, Pixel Loss: 0.5603, Edge Loss: 1.1924\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 78, Total Loss: 1.3914, Pixel Loss: 0.5623, Edge Loss: 1.1845\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 79, Total Loss: 1.3862, Pixel Loss: 0.5583, Edge Loss: 1.1827\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 80, Total Loss: 1.3854, Pixel Loss: 0.5525, Edge Loss: 1.1900\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 81, Total Loss: 1.3765, Pixel Loss: 0.5496, Edge Loss: 1.1813\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 82, Total Loss: 1.3722, Pixel Loss: 0.5492, Edge Loss: 1.1758\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 83, Total Loss: 1.3752, Pixel Loss: 0.5578, Edge Loss: 1.1677\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 84, Total Loss: 1.3557, Pixel Loss: 0.5406, Edge Loss: 1.1643\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 85, Total Loss: 1.3615, Pixel Loss: 0.5430, Edge Loss: 1.1693\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 86, Total Loss: 1.3522, Pixel Loss: 0.5367, Edge Loss: 1.1650\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 87, Total Loss: 1.3521, Pixel Loss: 0.5406, Edge Loss: 1.1594\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 88, Total Loss: 1.3426, Pixel Loss: 0.5357, Edge Loss: 1.1527\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 89, Total Loss: 1.3381, Pixel Loss: 0.5299, Edge Loss: 1.1545\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 90, Total Loss: 1.3303, Pixel Loss: 0.5247, Edge Loss: 1.1509\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 91, Total Loss: 1.3243, Pixel Loss: 0.5262, Edge Loss: 1.1402\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 92, Total Loss: 1.3241, Pixel Loss: 0.5216, Edge Loss: 1.1464\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 93, Total Loss: 1.3175, Pixel Loss: 0.5182, Edge Loss: 1.1419\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 94, Total Loss: 1.3184, Pixel Loss: 0.5209, Edge Loss: 1.1393\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 95, Total Loss: 1.3034, Pixel Loss: 0.5096, Edge Loss: 1.1339\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 96, Total Loss: 1.3002, Pixel Loss: 0.5118, Edge Loss: 1.1263\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 97, Total Loss: 1.2964, Pixel Loss: 0.5052, Edge Loss: 1.1303\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 98, Total Loss: 1.2928, Pixel Loss: 0.5143, Edge Loss: 1.1123\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 99, Total Loss: 1.2905, Pixel Loss: 0.4993, Edge Loss: 1.1302\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 100, Total Loss: 1.2743, Pixel Loss: 0.5021, Edge Loss: 1.1032\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 101, Total Loss: 1.2678, Pixel Loss: 0.4888, Edge Loss: 1.1129\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 102, Total Loss: 1.2702, Pixel Loss: 0.4862, Edge Loss: 1.1200\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 103, Total Loss: 1.2608, Pixel Loss: 0.4924, Edge Loss: 1.0977\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 104, Total Loss: 1.2533, Pixel Loss: 0.4792, Edge Loss: 1.1058\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 105, Total Loss: 1.2508, Pixel Loss: 0.4752, Edge Loss: 1.1080\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 106, Total Loss: 1.2495, Pixel Loss: 0.4903, Edge Loss: 1.0846\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 107, Total Loss: 1.2369, Pixel Loss: 0.4684, Edge Loss: 1.0978\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 108, Total Loss: 1.2303, Pixel Loss: 0.4644, Edge Loss: 1.0941\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 109, Total Loss: 1.2313, Pixel Loss: 0.4752, Edge Loss: 1.0801\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 110, Total Loss: 1.2248, Pixel Loss: 0.4597, Edge Loss: 1.0931\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 111, Total Loss: 1.2132, Pixel Loss: 0.4618, Edge Loss: 1.0733\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 112, Total Loss: 1.2073, Pixel Loss: 0.4564, Edge Loss: 1.0727\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 113, Total Loss: 1.2289, Pixel Loss: 0.4624, Edge Loss: 1.0949\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 114, Total Loss: 1.2490, Pixel Loss: 0.5177, Edge Loss: 1.0447\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 115, Total Loss: 1.1959, Pixel Loss: 0.4419, Edge Loss: 1.0772\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 116, Total Loss: 1.2032, Pixel Loss: 0.4479, Edge Loss: 1.0790\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 117, Total Loss: 1.2177, Pixel Loss: 0.4904, Edge Loss: 1.0390\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 118, Total Loss: 1.1772, Pixel Loss: 0.4351, Edge Loss: 1.0601\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 119, Total Loss: 1.2071, Pixel Loss: 0.4538, Edge Loss: 1.0761\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 120, Total Loss: 1.1917, Pixel Loss: 0.4651, Edge Loss: 1.0380\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 121, Total Loss: 1.1707, Pixel Loss: 0.4442, Edge Loss: 1.0379\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 122, Total Loss: 1.2047, Pixel Loss: 0.4547, Edge Loss: 1.0714\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 123, Total Loss: 1.1586, Pixel Loss: 0.4292, Edge Loss: 1.0420\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 124, Total Loss: 1.1796, Pixel Loss: 0.4636, Edge Loss: 1.0228\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 125, Total Loss: 1.1609, Pixel Loss: 0.4244, Edge Loss: 1.0521\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 126, Total Loss: 1.1384, Pixel Loss: 0.4146, Edge Loss: 1.0341\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 127, Total Loss: 1.1630, Pixel Loss: 0.4530, Edge Loss: 1.0142\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 128, Total Loss: 1.1283, Pixel Loss: 0.4093, Edge Loss: 1.0271\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 129, Total Loss: 1.1371, Pixel Loss: 0.4122, Edge Loss: 1.0356\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 130, Total Loss: 1.1289, Pixel Loss: 0.4238, Edge Loss: 1.0074\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 131, Total Loss: 1.1147, Pixel Loss: 0.4078, Edge Loss: 1.0099\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 132, Total Loss: 1.1226, Pixel Loss: 0.4069, Edge Loss: 1.0224\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 133, Total Loss: 1.1054, Pixel Loss: 0.4052, Edge Loss: 1.0004\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 134, Total Loss: 1.1049, Pixel Loss: 0.4058, Edge Loss: 0.9987\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 135, Total Loss: 1.0960, Pixel Loss: 0.3918, Edge Loss: 1.0060\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 136, Total Loss: 1.0873, Pixel Loss: 0.3959, Edge Loss: 0.9878\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 137, Total Loss: 1.0777, Pixel Loss: 0.3887, Edge Loss: 0.9843\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 138, Total Loss: 1.0850, Pixel Loss: 0.3860, Edge Loss: 0.9986\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 139, Total Loss: 1.0719, Pixel Loss: 0.3893, Edge Loss: 0.9751\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 140, Total Loss: 1.0666, Pixel Loss: 0.3818, Edge Loss: 0.9782\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 141, Total Loss: 1.0619, Pixel Loss: 0.3746, Edge Loss: 0.9819\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 142, Total Loss: 1.0525, Pixel Loss: 0.3818, Edge Loss: 0.9582\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 143, Total Loss: 1.0362, Pixel Loss: 0.3686, Edge Loss: 0.9537\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 144, Total Loss: 1.0379, Pixel Loss: 0.3643, Edge Loss: 0.9622\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 145, Total Loss: 1.0337, Pixel Loss: 0.3802, Edge Loss: 0.9336\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 146, Total Loss: 1.0243, Pixel Loss: 0.3593, Edge Loss: 0.9500\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 147, Total Loss: 1.0162, Pixel Loss: 0.3596, Edge Loss: 0.9380\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 148, Total Loss: 1.0090, Pixel Loss: 0.3572, Edge Loss: 0.9311\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 149, Total Loss: 1.0103, Pixel Loss: 0.3549, Edge Loss: 0.9363\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 150, Total Loss: 0.9995, Pixel Loss: 0.3565, Edge Loss: 0.9186\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 151, Total Loss: 0.9916, Pixel Loss: 0.3453, Edge Loss: 0.9232\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 152, Total Loss: 0.9865, Pixel Loss: 0.3460, Edge Loss: 0.9150\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 153, Total Loss: 0.9787, Pixel Loss: 0.3430, Edge Loss: 0.9082\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 154, Total Loss: 0.9698, Pixel Loss: 0.3389, Edge Loss: 0.9012\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 155, Total Loss: 0.9670, Pixel Loss: 0.3412, Edge Loss: 0.8941\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 156, Total Loss: 0.9715, Pixel Loss: 0.3395, Edge Loss: 0.9029\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 157, Total Loss: 0.9848, Pixel Loss: 0.3775, Edge Loss: 0.8675\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 158, Total Loss: 0.9642, Pixel Loss: 0.3400, Edge Loss: 0.8916\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 159, Total Loss: 0.9350, Pixel Loss: 0.3302, Edge Loss: 0.8640\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 160, Total Loss: 0.9397, Pixel Loss: 0.3332, Edge Loss: 0.8665\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 161, Total Loss: 0.9405, Pixel Loss: 0.3298, Edge Loss: 0.8724\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 162, Total Loss: 0.9322, Pixel Loss: 0.3411, Edge Loss: 0.8444\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 163, Total Loss: 0.9160, Pixel Loss: 0.3185, Edge Loss: 0.8536\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 164, Total Loss: 0.9093, Pixel Loss: 0.3140, Edge Loss: 0.8504\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 165, Total Loss: 0.9077, Pixel Loss: 0.3284, Edge Loss: 0.8276\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 166, Total Loss: 0.9070, Pixel Loss: 0.3174, Edge Loss: 0.8424\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 167, Total Loss: 0.8958, Pixel Loss: 0.3236, Edge Loss: 0.8174\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 168, Total Loss: 0.8748, Pixel Loss: 0.3014, Edge Loss: 0.8191\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 169, Total Loss: 0.8630, Pixel Loss: 0.3000, Edge Loss: 0.8044\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 170, Total Loss: 0.8629, Pixel Loss: 0.2978, Edge Loss: 0.8072\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 171, Total Loss: 0.8598, Pixel Loss: 0.2993, Edge Loss: 0.8008\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 172, Total Loss: 0.8512, Pixel Loss: 0.2926, Edge Loss: 0.7980\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 173, Total Loss: 0.8501, Pixel Loss: 0.3057, Edge Loss: 0.7777\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 174, Total Loss: 0.8695, Pixel Loss: 0.3141, Edge Loss: 0.7934\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 175, Total Loss: 0.8956, Pixel Loss: 0.3656, Edge Loss: 0.7571\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 176, Total Loss: 0.8414, Pixel Loss: 0.2963, Edge Loss: 0.7787\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 177, Total Loss: 0.8198, Pixel Loss: 0.2841, Edge Loss: 0.7653\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 178, Total Loss: 0.8245, Pixel Loss: 0.3015, Edge Loss: 0.7472\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 179, Total Loss: 0.8359, Pixel Loss: 0.2953, Edge Loss: 0.7722\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 180, Total Loss: 0.8098, Pixel Loss: 0.2883, Edge Loss: 0.7449\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 181, Total Loss: 0.8026, Pixel Loss: 0.2823, Edge Loss: 0.7432\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 182, Total Loss: 0.8143, Pixel Loss: 0.2898, Edge Loss: 0.7493\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 183, Total Loss: 0.8178, Pixel Loss: 0.3047, Edge Loss: 0.7330\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 184, Total Loss: 0.7978, Pixel Loss: 0.2782, Edge Loss: 0.7423\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 185, Total Loss: 0.7957, Pixel Loss: 0.2786, Edge Loss: 0.7387\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 186, Total Loss: 0.8045, Pixel Loss: 0.2975, Edge Loss: 0.7243\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 187, Total Loss: 0.7888, Pixel Loss: 0.2786, Edge Loss: 0.7289\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 188, Total Loss: 0.7802, Pixel Loss: 0.2780, Edge Loss: 0.7174\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 189, Total Loss: 0.7757, Pixel Loss: 0.2711, Edge Loss: 0.7207\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 190, Total Loss: 0.7733, Pixel Loss: 0.2718, Edge Loss: 0.7164\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 191, Total Loss: 0.7714, Pixel Loss: 0.2755, Edge Loss: 0.7084\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 192, Total Loss: 0.7790, Pixel Loss: 0.2741, Edge Loss: 0.7213\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 193, Total Loss: 0.7752, Pixel Loss: 0.2820, Edge Loss: 0.7045\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 194, Total Loss: 0.7674, Pixel Loss: 0.2667, Edge Loss: 0.7154\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 195, Total Loss: 0.7592, Pixel Loss: 0.2656, Edge Loss: 0.7051\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 196, Total Loss: 0.7580, Pixel Loss: 0.2673, Edge Loss: 0.7010\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 197, Total Loss: 0.7588, Pixel Loss: 0.2658, Edge Loss: 0.7043\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 198, Total Loss: 0.7554, Pixel Loss: 0.2718, Edge Loss: 0.6907\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 199, Total Loss: 0.7484, Pixel Loss: 0.2584, Edge Loss: 0.7001\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 200, Total Loss: 0.7449, Pixel Loss: 0.2623, Edge Loss: 0.6894\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 201, Total Loss: 0.7379, Pixel Loss: 0.2564, Edge Loss: 0.6878\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 202, Total Loss: 0.7350, Pixel Loss: 0.2520, Edge Loss: 0.6900\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 203, Total Loss: 0.7363, Pixel Loss: 0.2580, Edge Loss: 0.6832\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 204, Total Loss: 0.7290, Pixel Loss: 0.2502, Edge Loss: 0.6840\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 205, Total Loss: 0.7315, Pixel Loss: 0.2599, Edge Loss: 0.6738\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 206, Total Loss: 0.7307, Pixel Loss: 0.2531, Edge Loss: 0.6822\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 207, Total Loss: 0.7288, Pixel Loss: 0.2583, Edge Loss: 0.6721\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 208, Total Loss: 0.7194, Pixel Loss: 0.2477, Edge Loss: 0.6738\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 209, Total Loss: 0.7127, Pixel Loss: 0.2484, Edge Loss: 0.6633\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 210, Total Loss: 0.7150, Pixel Loss: 0.2490, Edge Loss: 0.6658\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 211, Total Loss: 0.7148, Pixel Loss: 0.2528, Edge Loss: 0.6601\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 212, Total Loss: 0.7109, Pixel Loss: 0.2476, Edge Loss: 0.6619\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 213, Total Loss: 0.7191, Pixel Loss: 0.2629, Edge Loss: 0.6516\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 214, Total Loss: 0.7122, Pixel Loss: 0.2509, Edge Loss: 0.6589\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 215, Total Loss: 0.7175, Pixel Loss: 0.2666, Edge Loss: 0.6441\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 216, Total Loss: 0.7113, Pixel Loss: 0.2517, Edge Loss: 0.6565\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 217, Total Loss: 0.7077, Pixel Loss: 0.2627, Edge Loss: 0.6357\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 218, Total Loss: 0.6993, Pixel Loss: 0.2455, Edge Loss: 0.6483\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 219, Total Loss: 0.6961, Pixel Loss: 0.2508, Edge Loss: 0.6361\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 220, Total Loss: 0.6937, Pixel Loss: 0.2441, Edge Loss: 0.6423\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 221, Total Loss: 0.6910, Pixel Loss: 0.2483, Edge Loss: 0.6323\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 222, Total Loss: 0.6857, Pixel Loss: 0.2381, Edge Loss: 0.6395\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 223, Total Loss: 0.6840, Pixel Loss: 0.2430, Edge Loss: 0.6300\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 224, Total Loss: 0.6829, Pixel Loss: 0.2359, Edge Loss: 0.6386\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 225, Total Loss: 0.6800, Pixel Loss: 0.2424, Edge Loss: 0.6252\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 226, Total Loss: 0.6839, Pixel Loss: 0.2388, Edge Loss: 0.6358\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 227, Total Loss: 0.6863, Pixel Loss: 0.2517, Edge Loss: 0.6208\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 228, Total Loss: 0.6937, Pixel Loss: 0.2474, Edge Loss: 0.6375\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 229, Total Loss: 0.6944, Pixel Loss: 0.2638, Edge Loss: 0.6151\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 230, Total Loss: 0.6863, Pixel Loss: 0.2447, Edge Loss: 0.6309\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 231, Total Loss: 0.6799, Pixel Loss: 0.2463, Edge Loss: 0.6193\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 232, Total Loss: 0.6663, Pixel Loss: 0.2305, Edge Loss: 0.6225\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 233, Total Loss: 0.6710, Pixel Loss: 0.2312, Edge Loss: 0.6283\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 234, Total Loss: 0.6710, Pixel Loss: 0.2408, Edge Loss: 0.6145\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 235, Total Loss: 0.6786, Pixel Loss: 0.2389, Edge Loss: 0.6281\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 236, Total Loss: 0.6829, Pixel Loss: 0.2555, Edge Loss: 0.6105\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 237, Total Loss: 0.6864, Pixel Loss: 0.2452, Edge Loss: 0.6303\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 238, Total Loss: 0.6701, Pixel Loss: 0.2405, Edge Loss: 0.6137\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 239, Total Loss: 0.6651, Pixel Loss: 0.2292, Edge Loss: 0.6227\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 240, Total Loss: 0.6608, Pixel Loss: 0.2281, Edge Loss: 0.6182\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 241, Total Loss: 0.6646, Pixel Loss: 0.2352, Edge Loss: 0.6135\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 242, Total Loss: 0.6673, Pixel Loss: 0.2337, Edge Loss: 0.6194\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 243, Total Loss: 0.6761, Pixel Loss: 0.2508, Edge Loss: 0.6076\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 244, Total Loss: 0.6689, Pixel Loss: 0.2344, Edge Loss: 0.6207\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 245, Total Loss: 0.6606, Pixel Loss: 0.2350, Edge Loss: 0.6079\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 246, Total Loss: 0.6566, Pixel Loss: 0.2265, Edge Loss: 0.6143\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 247, Total Loss: 0.6548, Pixel Loss: 0.2256, Edge Loss: 0.6132\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 248, Total Loss: 0.6545, Pixel Loss: 0.2314, Edge Loss: 0.6045\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 249, Total Loss: 0.6725, Pixel Loss: 0.2385, Edge Loss: 0.6200\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 250, Total Loss: 0.6851, Pixel Loss: 0.2633, Edge Loss: 0.6026\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 251, Total Loss: 0.6797, Pixel Loss: 0.2479, Edge Loss: 0.6169\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 252, Total Loss: 0.6738, Pixel Loss: 0.2530, Edge Loss: 0.6012\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 253, Total Loss: 0.6600, Pixel Loss: 0.2325, Edge Loss: 0.6107\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 254, Total Loss: 0.6628, Pixel Loss: 0.2395, Edge Loss: 0.6048\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 255, Total Loss: 0.6499, Pixel Loss: 0.2263, Edge Loss: 0.6051\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 256, Total Loss: 0.6517, Pixel Loss: 0.2302, Edge Loss: 0.6022\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 257, Total Loss: 0.6449, Pixel Loss: 0.2225, Edge Loss: 0.6035\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 258, Total Loss: 0.6433, Pixel Loss: 0.2216, Edge Loss: 0.6024\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 259, Total Loss: 0.6465, Pixel Loss: 0.2247, Edge Loss: 0.6026\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 260, Total Loss: 0.6503, Pixel Loss: 0.2246, Edge Loss: 0.6081\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 261, Total Loss: 0.6485, Pixel Loss: 0.2291, Edge Loss: 0.5991\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 262, Total Loss: 0.6496, Pixel Loss: 0.2244, Edge Loss: 0.6074\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 263, Total Loss: 0.6521, Pixel Loss: 0.2343, Edge Loss: 0.5968\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 264, Total Loss: 0.6559, Pixel Loss: 0.2294, Edge Loss: 0.6092\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 265, Total Loss: 0.6518, Pixel Loss: 0.2368, Edge Loss: 0.5928\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 266, Total Loss: 0.6525, Pixel Loss: 0.2285, Edge Loss: 0.6058\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 267, Total Loss: 0.6478, Pixel Loss: 0.2331, Edge Loss: 0.5923\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 268, Total Loss: 0.6460, Pixel Loss: 0.2236, Edge Loss: 0.6034\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 269, Total Loss: 0.6416, Pixel Loss: 0.2224, Edge Loss: 0.5989\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 270, Total Loss: 0.6405, Pixel Loss: 0.2220, Edge Loss: 0.5979\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 271, Total Loss: 0.6426, Pixel Loss: 0.2221, Edge Loss: 0.6008\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 272, Total Loss: 0.6489, Pixel Loss: 0.2353, Edge Loss: 0.5909\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 273, Total Loss: 0.6616, Pixel Loss: 0.2376, Edge Loss: 0.6058\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 274, Total Loss: 0.6683, Pixel Loss: 0.2618, Edge Loss: 0.5807\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 275, Total Loss: 0.6734, Pixel Loss: 0.2473, Edge Loss: 0.6086\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 276, Total Loss: 0.6557, Pixel Loss: 0.2446, Edge Loss: 0.5873\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 277, Total Loss: 0.6386, Pixel Loss: 0.2192, Edge Loss: 0.5991\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 278, Total Loss: 0.6347, Pixel Loss: 0.2182, Edge Loss: 0.5949\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 279, Total Loss: 0.6454, Pixel Loss: 0.2350, Edge Loss: 0.5862\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 280, Total Loss: 0.6804, Pixel Loss: 0.2553, Edge Loss: 0.6073\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 281, Total Loss: 0.6996, Pixel Loss: 0.2971, Edge Loss: 0.5750\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 282, Total Loss: 0.6507, Pixel Loss: 0.2277, Edge Loss: 0.6044\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 283, Total Loss: 0.6356, Pixel Loss: 0.2182, Edge Loss: 0.5962\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 284, Total Loss: 0.6584, Pixel Loss: 0.2479, Edge Loss: 0.5864\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 285, Total Loss: 0.6635, Pixel Loss: 0.2464, Edge Loss: 0.5958\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 286, Total Loss: 0.6665, Pixel Loss: 0.2597, Edge Loss: 0.5811\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 287, Total Loss: 0.6452, Pixel Loss: 0.2267, Edge Loss: 0.5979\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 288, Total Loss: 0.6317, Pixel Loss: 0.2187, Edge Loss: 0.5900\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 289, Total Loss: 0.6330, Pixel Loss: 0.2216, Edge Loss: 0.5877\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 290, Total Loss: 0.6348, Pixel Loss: 0.2208, Edge Loss: 0.5915\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 291, Total Loss: 0.6519, Pixel Loss: 0.2407, Edge Loss: 0.5875\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 292, Total Loss: 0.6424, Pixel Loss: 0.2259, Edge Loss: 0.5949\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 293, Total Loss: 0.6365, Pixel Loss: 0.2271, Edge Loss: 0.5848\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 294, Total Loss: 0.6347, Pixel Loss: 0.2184, Edge Loss: 0.5948\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 295, Total Loss: 0.6271, Pixel Loss: 0.2185, Edge Loss: 0.5837\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 296, Total Loss: 0.6278, Pixel Loss: 0.2144, Edge Loss: 0.5905\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 297, Total Loss: 0.6262, Pixel Loss: 0.2133, Edge Loss: 0.5898\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 298, Total Loss: 0.6316, Pixel Loss: 0.2201, Edge Loss: 0.5878\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 299, Total Loss: 0.6449, Pixel Loss: 0.2268, Edge Loss: 0.5973\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 300, Total Loss: 0.6477, Pixel Loss: 0.2396, Edge Loss: 0.5829\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 301, Total Loss: 0.6343, Pixel Loss: 0.2194, Edge Loss: 0.5926\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 302, Total Loss: 0.6263, Pixel Loss: 0.2181, Edge Loss: 0.5832\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 303, Total Loss: 0.6240, Pixel Loss: 0.2144, Edge Loss: 0.5850\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 304, Total Loss: 0.6327, Pixel Loss: 0.2193, Edge Loss: 0.5906\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 305, Total Loss: 0.6435, Pixel Loss: 0.2343, Edge Loss: 0.5845\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 306, Total Loss: 0.6354, Pixel Loss: 0.2211, Edge Loss: 0.5919\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 307, Total Loss: 0.6293, Pixel Loss: 0.2241, Edge Loss: 0.5789\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 308, Total Loss: 0.6264, Pixel Loss: 0.2140, Edge Loss: 0.5892\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 309, Total Loss: 0.6248, Pixel Loss: 0.2182, Edge Loss: 0.5808\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 310, Total Loss: 0.6188, Pixel Loss: 0.2106, Edge Loss: 0.5831\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 311, Total Loss: 0.6249, Pixel Loss: 0.2147, Edge Loss: 0.5860\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 312, Total Loss: 0.6245, Pixel Loss: 0.2148, Edge Loss: 0.5852\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 313, Total Loss: 0.6245, Pixel Loss: 0.2125, Edge Loss: 0.5885\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 314, Total Loss: 0.6265, Pixel Loss: 0.2223, Edge Loss: 0.5775\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 315, Total Loss: 0.6403, Pixel Loss: 0.2267, Edge Loss: 0.5908\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 316, Total Loss: 0.6521, Pixel Loss: 0.2505, Edge Loss: 0.5737\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 317, Total Loss: 0.6539, Pixel Loss: 0.2394, Edge Loss: 0.5922\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 318, Total Loss: 0.6445, Pixel Loss: 0.2451, Edge Loss: 0.5706\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 319, Total Loss: 0.6238, Pixel Loss: 0.2128, Edge Loss: 0.5870\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 320, Total Loss: 0.6184, Pixel Loss: 0.2111, Edge Loss: 0.5819\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 321, Total Loss: 0.6225, Pixel Loss: 0.2189, Edge Loss: 0.5766\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 322, Total Loss: 0.6371, Pixel Loss: 0.2259, Edge Loss: 0.5874\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 323, Total Loss: 0.6473, Pixel Loss: 0.2475, Edge Loss: 0.5711\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 324, Total Loss: 0.6372, Pixel Loss: 0.2255, Edge Loss: 0.5881\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 325, Total Loss: 0.6284, Pixel Loss: 0.2282, Edge Loss: 0.5718\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 326, Total Loss: 0.6212, Pixel Loss: 0.2144, Edge Loss: 0.5811\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 327, Total Loss: 0.6191, Pixel Loss: 0.2150, Edge Loss: 0.5773\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 328, Total Loss: 0.6141, Pixel Loss: 0.2078, Edge Loss: 0.5805\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 329, Total Loss: 0.6164, Pixel Loss: 0.2113, Edge Loss: 0.5787\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 330, Total Loss: 0.6156, Pixel Loss: 0.2088, Edge Loss: 0.5812\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 331, Total Loss: 0.6155, Pixel Loss: 0.2103, Edge Loss: 0.5789\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 332, Total Loss: 0.6117, Pixel Loss: 0.2098, Edge Loss: 0.5741\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 333, Total Loss: 0.6145, Pixel Loss: 0.2085, Edge Loss: 0.5800\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 334, Total Loss: 0.6190, Pixel Loss: 0.2102, Edge Loss: 0.5839\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 335, Total Loss: 0.6149, Pixel Loss: 0.2156, Edge Loss: 0.5705\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 336, Total Loss: 0.6385, Pixel Loss: 0.2261, Edge Loss: 0.5891\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 337, Total Loss: 0.6579, Pixel Loss: 0.2601, Edge Loss: 0.5682\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 338, Total Loss: 0.6420, Pixel Loss: 0.2346, Edge Loss: 0.5820\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 339, Total Loss: 0.6337, Pixel Loss: 0.2382, Edge Loss: 0.5650\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 340, Total Loss: 0.6133, Pixel Loss: 0.2099, Edge Loss: 0.5763\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 341, Total Loss: 0.6109, Pixel Loss: 0.2072, Edge Loss: 0.5768\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 342, Total Loss: 0.6120, Pixel Loss: 0.2080, Edge Loss: 0.5771\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 343, Total Loss: 0.6143, Pixel Loss: 0.2095, Edge Loss: 0.5783\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 344, Total Loss: 0.6166, Pixel Loss: 0.2180, Edge Loss: 0.5694\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 345, Total Loss: 0.6338, Pixel Loss: 0.2207, Edge Loss: 0.5901\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 346, Total Loss: 0.6326, Pixel Loss: 0.2359, Edge Loss: 0.5667\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 347, Total Loss: 0.6363, Pixel Loss: 0.2274, Edge Loss: 0.5842\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 348, Total Loss: 0.6299, Pixel Loss: 0.2309, Edge Loss: 0.5700\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 349, Total Loss: 0.6152, Pixel Loss: 0.2109, Edge Loss: 0.5776\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 350, Total Loss: 0.6119, Pixel Loss: 0.2093, Edge Loss: 0.5752\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 351, Total Loss: 0.6049, Pixel Loss: 0.2054, Edge Loss: 0.5707\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 352, Total Loss: 0.6156, Pixel Loss: 0.2104, Edge Loss: 0.5788\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 353, Total Loss: 0.6225, Pixel Loss: 0.2271, Edge Loss: 0.5648\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 354, Total Loss: 0.6422, Pixel Loss: 0.2332, Edge Loss: 0.5842\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 355, Total Loss: 0.6446, Pixel Loss: 0.2514, Edge Loss: 0.5616\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 356, Total Loss: 0.6294, Pixel Loss: 0.2207, Edge Loss: 0.5839\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 357, Total Loss: 0.6135, Pixel Loss: 0.2133, Edge Loss: 0.5717\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 358, Total Loss: 0.6035, Pixel Loss: 0.2031, Edge Loss: 0.5719\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 359, Total Loss: 0.6074, Pixel Loss: 0.2067, Edge Loss: 0.5723\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 360, Total Loss: 0.6068, Pixel Loss: 0.2081, Edge Loss: 0.5696\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 361, Total Loss: 0.6103, Pixel Loss: 0.2056, Edge Loss: 0.5781\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 362, Total Loss: 0.6035, Pixel Loss: 0.2053, Edge Loss: 0.5688\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 363, Total Loss: 0.6042, Pixel Loss: 0.2037, Edge Loss: 0.5721\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 364, Total Loss: 0.6067, Pixel Loss: 0.2039, Edge Loss: 0.5755\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 365, Total Loss: 0.6084, Pixel Loss: 0.2114, Edge Loss: 0.5671\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 366, Total Loss: 0.6128, Pixel Loss: 0.2083, Edge Loss: 0.5778\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 367, Total Loss: 0.6284, Pixel Loss: 0.2329, Edge Loss: 0.5651\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 368, Total Loss: 0.6417, Pixel Loss: 0.2361, Edge Loss: 0.5795\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 369, Total Loss: 0.6418, Pixel Loss: 0.2511, Edge Loss: 0.5582\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 370, Total Loss: 0.6218, Pixel Loss: 0.2181, Edge Loss: 0.5767\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 371, Total Loss: 0.6111, Pixel Loss: 0.2147, Edge Loss: 0.5662\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 372, Total Loss: 0.6061, Pixel Loss: 0.2041, Edge Loss: 0.5743\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 373, Total Loss: 0.6051, Pixel Loss: 0.2055, Edge Loss: 0.5708\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 374, Total Loss: 0.6030, Pixel Loss: 0.2039, Edge Loss: 0.5702\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 375, Total Loss: 0.6088, Pixel Loss: 0.2144, Edge Loss: 0.5635\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 376, Total Loss: 0.6237, Pixel Loss: 0.2193, Edge Loss: 0.5777\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 377, Total Loss: 0.6415, Pixel Loss: 0.2498, Edge Loss: 0.5595\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 378, Total Loss: 0.6338, Pixel Loss: 0.2300, Edge Loss: 0.5768\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 379, Total Loss: 0.6157, Pixel Loss: 0.2258, Edge Loss: 0.5570\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 380, Total Loss: 0.6021, Pixel Loss: 0.2037, Edge Loss: 0.5691\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 381, Total Loss: 0.5967, Pixel Loss: 0.2001, Edge Loss: 0.5666\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 382, Total Loss: 0.6002, Pixel Loss: 0.2083, Edge Loss: 0.5599\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 383, Total Loss: 0.6112, Pixel Loss: 0.2106, Edge Loss: 0.5722\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 384, Total Loss: 0.6142, Pixel Loss: 0.2213, Edge Loss: 0.5613\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 385, Total Loss: 0.6102, Pixel Loss: 0.2088, Edge Loss: 0.5735\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 386, Total Loss: 0.6025, Pixel Loss: 0.2053, Edge Loss: 0.5674\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 387, Total Loss: 0.6015, Pixel Loss: 0.2053, Edge Loss: 0.5661\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 388, Total Loss: 0.6159, Pixel Loss: 0.2153, Edge Loss: 0.5722\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 389, Total Loss: 0.6477, Pixel Loss: 0.2588, Edge Loss: 0.5556\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 390, Total Loss: 0.6396, Pixel Loss: 0.2360, Edge Loss: 0.5765\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 391, Total Loss: 0.6130, Pixel Loss: 0.2235, Edge Loss: 0.5565\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 392, Total Loss: 0.6009, Pixel Loss: 0.2037, Edge Loss: 0.5674\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 393, Total Loss: 0.5987, Pixel Loss: 0.2039, Edge Loss: 0.5640\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 394, Total Loss: 0.5976, Pixel Loss: 0.2021, Edge Loss: 0.5650\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 395, Total Loss: 0.5993, Pixel Loss: 0.2013, Edge Loss: 0.5686\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 396, Total Loss: 0.6088, Pixel Loss: 0.2157, Edge Loss: 0.5616\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 397, Total Loss: 0.6232, Pixel Loss: 0.2189, Edge Loss: 0.5775\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 398, Total Loss: 0.6359, Pixel Loss: 0.2455, Edge Loss: 0.5576\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 399, Total Loss: 0.6145, Pixel Loss: 0.2161, Edge Loss: 0.5691\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 400, Total Loss: 0.6052, Pixel Loss: 0.2129, Edge Loss: 0.5603\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 401, Total Loss: 0.5972, Pixel Loss: 0.2023, Edge Loss: 0.5642\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 402, Total Loss: 0.5981, Pixel Loss: 0.2019, Edge Loss: 0.5660\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 403, Total Loss: 0.6117, Pixel Loss: 0.2210, Edge Loss: 0.5581\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 404, Total Loss: 0.6172, Pixel Loss: 0.2198, Edge Loss: 0.5676\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 405, Total Loss: 0.6283, Pixel Loss: 0.2408, Edge Loss: 0.5536\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 406, Total Loss: 0.6210, Pixel Loss: 0.2197, Edge Loss: 0.5733\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 407, Total Loss: 0.6166, Pixel Loss: 0.2282, Edge Loss: 0.5549\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 408, Total Loss: 0.6039, Pixel Loss: 0.2073, Edge Loss: 0.5665\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 409, Total Loss: 0.5949, Pixel Loss: 0.2027, Edge Loss: 0.5602\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 410, Total Loss: 0.5925, Pixel Loss: 0.2010, Edge Loss: 0.5594\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 411, Total Loss: 0.5942, Pixel Loss: 0.2018, Edge Loss: 0.5607\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 412, Total Loss: 0.6056, Pixel Loss: 0.2155, Edge Loss: 0.5573\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 413, Total Loss: 0.6093, Pixel Loss: 0.2135, Edge Loss: 0.5655\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 414, Total Loss: 0.6157, Pixel Loss: 0.2292, Edge Loss: 0.5522\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 415, Total Loss: 0.6097, Pixel Loss: 0.2122, Edge Loss: 0.5678\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 416, Total Loss: 0.6045, Pixel Loss: 0.2160, Edge Loss: 0.5550\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 417, Total Loss: 0.5965, Pixel Loss: 0.2022, Edge Loss: 0.5633\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 418, Total Loss: 0.5901, Pixel Loss: 0.1982, Edge Loss: 0.5599\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 419, Total Loss: 0.5954, Pixel Loss: 0.2044, Edge Loss: 0.5585\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 420, Total Loss: 0.6087, Pixel Loss: 0.2099, Edge Loss: 0.5698\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 421, Total Loss: 0.6198, Pixel Loss: 0.2314, Edge Loss: 0.5549\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 422, Total Loss: 0.6155, Pixel Loss: 0.2158, Edge Loss: 0.5710\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 423, Total Loss: 0.6003, Pixel Loss: 0.2126, Edge Loss: 0.5539\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 424, Total Loss: 0.5941, Pixel Loss: 0.2010, Edge Loss: 0.5616\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 425, Total Loss: 0.5877, Pixel Loss: 0.1978, Edge Loss: 0.5571\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 426, Total Loss: 0.5917, Pixel Loss: 0.2018, Edge Loss: 0.5570\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 427, Total Loss: 0.5980, Pixel Loss: 0.2046, Edge Loss: 0.5620\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 428, Total Loss: 0.5962, Pixel Loss: 0.2064, Edge Loss: 0.5569\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 429, Total Loss: 0.5950, Pixel Loss: 0.2015, Edge Loss: 0.5622\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 430, Total Loss: 0.5994, Pixel Loss: 0.2115, Edge Loss: 0.5541\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 431, Total Loss: 0.5984, Pixel Loss: 0.2026, Edge Loss: 0.5654\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 432, Total Loss: 0.6041, Pixel Loss: 0.2145, Edge Loss: 0.5566\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 433, Total Loss: 0.5906, Pixel Loss: 0.1973, Edge Loss: 0.5618\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 434, Total Loss: 0.5924, Pixel Loss: 0.2024, Edge Loss: 0.5571\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 435, Total Loss: 0.5891, Pixel Loss: 0.1987, Edge Loss: 0.5576\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 436, Total Loss: 0.5909, Pixel Loss: 0.1993, Edge Loss: 0.5594\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 437, Total Loss: 0.5869, Pixel Loss: 0.1970, Edge Loss: 0.5570\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 438, Total Loss: 0.5916, Pixel Loss: 0.1973, Edge Loss: 0.5634\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 439, Total Loss: 0.5899, Pixel Loss: 0.2009, Edge Loss: 0.5558\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 440, Total Loss: 0.5867, Pixel Loss: 0.1963, Edge Loss: 0.5576\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 441, Total Loss: 0.5917, Pixel Loss: 0.2029, Edge Loss: 0.5554\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 442, Total Loss: 0.5971, Pixel Loss: 0.2023, Edge Loss: 0.5639\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 443, Total Loss: 0.6010, Pixel Loss: 0.2131, Edge Loss: 0.5541\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 444, Total Loss: 0.6032, Pixel Loss: 0.2106, Edge Loss: 0.5609\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 445, Total Loss: 0.6143, Pixel Loss: 0.2315, Edge Loss: 0.5470\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 446, Total Loss: 0.6122, Pixel Loss: 0.2179, Edge Loss: 0.5632\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 447, Total Loss: 0.6115, Pixel Loss: 0.2292, Edge Loss: 0.5461\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 448, Total Loss: 0.6060, Pixel Loss: 0.2113, Edge Loss: 0.5639\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 449, Total Loss: 0.5954, Pixel Loss: 0.2118, Edge Loss: 0.5480\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 450, Total Loss: 0.5897, Pixel Loss: 0.1979, Edge Loss: 0.5598\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 451, Total Loss: 0.5830, Pixel Loss: 0.1964, Edge Loss: 0.5523\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 452, Total Loss: 0.5870, Pixel Loss: 0.2023, Edge Loss: 0.5495\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 453, Total Loss: 0.6000, Pixel Loss: 0.2078, Edge Loss: 0.5604\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 454, Total Loss: 0.6284, Pixel Loss: 0.2457, Edge Loss: 0.5467\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 455, Total Loss: 0.6231, Pixel Loss: 0.2291, Edge Loss: 0.5629\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 456, Total Loss: 0.6065, Pixel Loss: 0.2233, Edge Loss: 0.5474\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 457, Total Loss: 0.5919, Pixel Loss: 0.1979, Edge Loss: 0.5629\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 458, Total Loss: 0.5910, Pixel Loss: 0.1993, Edge Loss: 0.5596\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 459, Total Loss: 0.6020, Pixel Loss: 0.2169, Edge Loss: 0.5501\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 460, Total Loss: 0.6005, Pixel Loss: 0.2069, Edge Loss: 0.5624\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 461, Total Loss: 0.5960, Pixel Loss: 0.2105, Edge Loss: 0.5507\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 462, Total Loss: 0.5860, Pixel Loss: 0.1966, Edge Loss: 0.5564\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 463, Total Loss: 0.5899, Pixel Loss: 0.2014, Edge Loss: 0.5550\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 464, Total Loss: 0.5899, Pixel Loss: 0.1998, Edge Loss: 0.5572\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 465, Total Loss: 0.5881, Pixel Loss: 0.2006, Edge Loss: 0.5535\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 466, Total Loss: 0.5872, Pixel Loss: 0.1962, Edge Loss: 0.5585\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 467, Total Loss: 0.5866, Pixel Loss: 0.1966, Edge Loss: 0.5571\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 468, Total Loss: 0.5885, Pixel Loss: 0.1988, Edge Loss: 0.5567\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 469, Total Loss: 0.5898, Pixel Loss: 0.2006, Edge Loss: 0.5560\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 470, Total Loss: 0.6015, Pixel Loss: 0.2203, Edge Loss: 0.5446\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 471, Total Loss: 0.6258, Pixel Loss: 0.2304, Edge Loss: 0.5649\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 472, Total Loss: 0.6411, Pixel Loss: 0.2616, Edge Loss: 0.5422\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 473, Total Loss: 0.6113, Pixel Loss: 0.2193, Edge Loss: 0.5600\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 474, Total Loss: 0.5865, Pixel Loss: 0.2037, Edge Loss: 0.5469\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 475, Total Loss: 0.5854, Pixel Loss: 0.1971, Edge Loss: 0.5548\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 476, Total Loss: 0.5893, Pixel Loss: 0.2014, Edge Loss: 0.5542\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 477, Total Loss: 0.6028, Pixel Loss: 0.2253, Edge Loss: 0.5393\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 478, Total Loss: 0.6200, Pixel Loss: 0.2262, Edge Loss: 0.5626\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 479, Total Loss: 0.6148, Pixel Loss: 0.2331, Edge Loss: 0.5453\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 480, Total Loss: 0.5876, Pixel Loss: 0.2006, Edge Loss: 0.5528\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 481, Total Loss: 0.5849, Pixel Loss: 0.1987, Edge Loss: 0.5518\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 482, Total Loss: 0.5927, Pixel Loss: 0.2132, Edge Loss: 0.5421\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 483, Total Loss: 0.6132, Pixel Loss: 0.2195, Edge Loss: 0.5624\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 484, Total Loss: 0.6213, Pixel Loss: 0.2426, Edge Loss: 0.5410\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 485, Total Loss: 0.5985, Pixel Loss: 0.2086, Edge Loss: 0.5570\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 486, Total Loss: 0.5879, Pixel Loss: 0.2014, Edge Loss: 0.5522\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 487, Total Loss: 0.5809, Pixel Loss: 0.1959, Edge Loss: 0.5500\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 488, Total Loss: 0.5939, Pixel Loss: 0.2032, Edge Loss: 0.5581\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 489, Total Loss: 0.6124, Pixel Loss: 0.2333, Edge Loss: 0.5415\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 490, Total Loss: 0.6174, Pixel Loss: 0.2252, Edge Loss: 0.5604\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 491, Total Loss: 0.6072, Pixel Loss: 0.2300, Edge Loss: 0.5388\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 492, Total Loss: 0.5863, Pixel Loss: 0.1997, Edge Loss: 0.5523\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 493, Total Loss: 0.5815, Pixel Loss: 0.1961, Edge Loss: 0.5505\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 494, Total Loss: 0.5900, Pixel Loss: 0.2096, Edge Loss: 0.5434\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 495, Total Loss: 0.6082, Pixel Loss: 0.2182, Edge Loss: 0.5572\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 496, Total Loss: 0.6256, Pixel Loss: 0.2501, Edge Loss: 0.5365\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 497, Total Loss: 0.6032, Pixel Loss: 0.2124, Edge Loss: 0.5583\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 498, Total Loss: 0.5854, Pixel Loss: 0.2035, Edge Loss: 0.5456\n",
      "output shape is torch.Size([1, 1, 480, 640])\n",
      "Epoch 499, Total Loss: 0.5762, Pixel Loss: 0.1940, Edge Loss: 0.5461\n"
     ]
    }
   ],
   "source": [
    "refine_net= train_one_epoch(cres_stereo_tensor.to('cuda'), mono_stereo_tensor.to('cuda'), n_iters=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "refine_net_reset = train_one_epoch_resnet(cres_stereo_tensor.to('cuda'), mono_stereo_tensor.to('cuda'), n_iters=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "refine_net_mbv3 = train_one_epoch_mbv3(cres_stereo_tensor.to('cuda'), mono_stereo_tensor.to('cuda'), n_iters=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "refine_net.eval()\n",
    "\n",
    "with torch.no_grad():\n",
    "    # norm_stereo, v_min, v_max = tensor_norm(cres_stereo_tensor)\n",
    "    # norm_mono, _, _ = tensor_norm(mono_stereo_tensor)\n",
    "    norm_stereo = cres_stereo_tensor\n",
    "    norm_mono = mono_stereo_tensor\n",
    "\n",
    "    fusion_disp = refine_net(norm_stereo.to('cuda'), norm_mono.to('cuda'))\n",
    "    # fusion_disp_backup = fusion_disp*(v_max-v_min)+v_min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "fusion = fusion_disp.cpu().numpy()\n",
    "# fusion_backup = fusion_disp_backup.cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 7.7173715  8.8742695 11.642316  ... 10.373497   7.25896    6.9728403]\n",
      " [ 9.259249   8.9924555 12.066889  ... 11.042152   8.529521   8.5293   ]\n",
      " [11.242772  11.538228  12.533223  ... 11.74105   10.550647  10.275288 ]\n",
      " ...\n",
      " [13.04739   13.680065  14.325819  ... 15.591226  14.728168  14.227705 ]\n",
      " [10.219582  10.672497  13.980699  ... 15.38571   12.369868  12.4865885]\n",
      " [ 9.014719  11.41853   14.147731  ... 13.500341  10.304068   8.064547 ]]\n"
     ]
    }
   ],
   "source": [
    "fusion = fusion[0,0,...]\n",
    "print(fusion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4.899589  4.877498  4.866714  ... 4.3076706 4.3492527 3.600375 ]\n",
      " [4.919932  4.8577075 4.8232794 ... 4.339977  4.254379  4.1151423]\n",
      " [4.900367  4.859409  4.8749313 ... 4.3423605 4.331066  4.2994246]\n",
      " ...\n",
      " [5.3741436 5.3813066 5.380779  ... 5.1638484 5.149842  5.168496 ]\n",
      " [5.3965325 5.3815565 5.379775  ... 5.195264  5.196157  5.1949015]\n",
      " [5.3248515 5.3834567 5.331273  ... 5.211009  5.2226243 5.2281513]]\n"
     ]
    }
   ],
   "source": [
    "print(mono_numpy_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 8.033481   9.703671  11.184143  ... 10.998613   9.539995   7.8271565]\n",
      " [ 9.5815525  9.842273  11.859487  ... 11.45709   10.031179   8.955717 ]\n",
      " [11.750618  11.947166  12.691617  ... 12.201325  11.651431  11.546079 ]\n",
      " ...\n",
      " [13.231781  13.893424  14.13245   ... 15.375398  14.649236  14.323336 ]\n",
      " [10.347188  12.26498   13.883181  ... 14.236204  12.88722   11.083495 ]\n",
      " [ 7.8832455 11.233721  12.901068  ... 14.680025  12.165562  10.041147 ]]\n"
     ]
    }
   ],
   "source": [
    "# fusion_backup = fusion_backup[0,0,...]\n",
    "# print(fusion_backup)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[14.192608 14.202011 14.199517 ... 13.018124 13.018322 13.018267]\n",
      " [14.200415 14.197662 14.19595  ... 13.017286 13.010814 13.014877]\n",
      " [14.197171 14.193902 14.195598 ... 13.014473 13.007282 13.003704]\n",
      " ...\n",
      " [15.953414 15.967855 15.975756 ... 16.743542 16.727856 16.710512]\n",
      " [15.967464 15.97843  15.983091 ... 16.85468  16.842308 16.823545]\n",
      " [15.968182 15.981563 15.986776 ... 16.949951 16.93787  16.933857]]\n"
     ]
    }
   ],
   "source": [
    "print(cres_numpy_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "refine_net_reset.eval()\n",
    "refine_net_mbv3.eval()\n",
    "orig_h, orig_w = 480, 640\n",
    "with torch.no_grad():\n",
    "    resnet_fusion_output = refine_net_reset(cres_stereo_tensor.to('cuda'), mono_stereo_tensor.to('cuda'))\n",
    "    resnet_fusion_output = F.interpolate(resnet_fusion_output, (orig_h, orig_w), mode='bilinear', align_corners=True)\n",
    "    mbv3_fusion_output = refine_net_mbv3(cres_stereo_tensor.to('cuda'), mono_stereo_tensor.to('cuda'))\n",
    "    mbv3_fusion_output = F.interpolate(mbv3_fusion_output, (orig_h, orig_w), mode='bilinear', align_corners=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "resent_fusion_numpy = resnet_fusion_output.cpu().squeeze(1).squeeze(0).numpy()\n",
    "mbv3_fusion_numpy = mbv3_fusion_output.cpu().squeeze(1).squeeze(0).numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resent_fusion_numpy.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mbv3_fusion_numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resent_fusion_numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.imshow(resent_fusion_numpy, cmap='magma')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure()\n",
    "plt.imshow(mbv3_fusion_numpy, cmap='magma')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch2.3.1_cu12.1",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}