{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "indoor-billion",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sandesh\n",
    "import os\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "\n",
    "def LoadSceneAndLabel(dirnameScene, dirnameLabel, numImages):\n",
    "    count = 0\n",
    "    sceneX = []\n",
    "    sceneY = []\n",
    "    for sceneName in os.listdir(dirnameScene):\n",
    "        scene = Image.open(os.path.join(dirnameScene, sceneName))\n",
    "        sceneLabel = Image.open(os.path.join(dirnameLabel, sceneName[:-4]+\"_drivable_color.png\"))\n",
    "        #scene.show()\n",
    "        #sceneLabel.show()\n",
    "        #print(scene.size)\n",
    "        #print(sceneLabel.size)\n",
    "        sceneX.append(scene)\n",
    "        sceneY.append(sceneLabel)\n",
    "        count += 1\n",
    "        if count >= numImages:\n",
    "          break\n",
    "    return sceneX, sceneY\n",
    "\n",
    "dataX, dataY = LoadSceneAndLabel(dirnameScene=\"bdd100k_images/images/100k/train\", dirnameLabel=\"bdd100k_drivable_map/drivable_maps/color_labels/train\", numImages=50)\n",
    "valX, valY = LoadSceneAndLabel(dirnameScene=\"bdd100k_images/images/100k/val\", dirnameLabel=\"bdd100k_drivable_map/drivable_maps/color_labels/val\", numImages=50)\n",
    "\n",
    "dataX[0].size\n",
    "\n",
    "xSize = 720\n",
    "ySize = 1280"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "sufficient-thomson",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "removable-serial",
   "metadata": {},
   "source": [
    "# Compress"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "international-narrow",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def compress(x, y, rate=0.1):  # compress one image and its label image\n",
    "    global xSize\n",
    "    global ySize\n",
    "    #print(x.size)\n",
    "    xSize = math.floor(x.size[0]*rate)\n",
    "    ySize = math.floor(x.size[1]*rate)\n",
    "    \n",
    "    x = x.resize([xSize, ySize])  \n",
    "    y = y.resize([xSize, ySize])  \n",
    "    #print(x.size)\n",
    "\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "brief-opening",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = dataX[0]\n",
    "y = dataY[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "retained-highlight",
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = compress(x, y, rate=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "controlled-nelson",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f686d5cbd50>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "surgical-luxembourg",
   "metadata": {},
   "source": [
    "# Transform - flips"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "separated-equity",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# \n",
    "\n",
    "# #list is pass by reference so copy isn't made\n",
    "import torchvision.transforms.functional as TF\n",
    "import random\n",
    "\n",
    "def transformImages(image, mask):\n",
    "\n",
    "\n",
    "    # Random horizontal flipping\n",
    "    if random.random() > 0.5:\n",
    "        image = TF.hflip(image)\n",
    "        mask = TF.hflip(mask)\n",
    "\n",
    "        # Random vertical flipping\n",
    "#         if random.random() > 0.5:\n",
    "#             image = TF.vflip(image)\n",
    "#             mask = TF.vflip(mask)\n",
    "\n",
    "#         # Transform to tensor\n",
    "#         image = TF.to_tensor(image)\n",
    "#         mask = TF.to_tensor(mask)\n",
    "    return image, mask\n",
    "    \n",
    "#transform dataX and dataY, doesn't return anything since passed by reference\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "german-validity",
   "metadata": {},
   "source": [
    "# Convert to array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "guided-northeast",
   "metadata": {},
   "outputs": [],
   "source": [
    "# \n",
    "#convert non zero label to be the same number so it's not different based on different lane categorization\n",
    "\n",
    "def convert_to_array(x, y):  # convert one single pair of image and label\n",
    "    x = np.array(x)\n",
    "    #divide by 255.0\n",
    "    x = np.divide(x, 255.0)\n",
    "\n",
    "    y = y.convert('LA')  # convert to grayscale\n",
    "    y = np.squeeze(np.array(y)[:,:,0])\n",
    "    y = np.where(y > 0, 1, 0)\n",
    "\n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "unavailable-oxide",
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = convert_to_array(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "emotional-colorado",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.32941176, 0.61176471, 0.94117647],\n",
       "        [0.32941176, 0.61176471, 0.94117647],\n",
       "        [0.33333333, 0.61568627, 0.94509804],\n",
       "        ...,\n",
       "        [0.03137255, 0.0627451 , 0.0745098 ],\n",
       "        [0.02745098, 0.04705882, 0.06666667],\n",
       "        [0.02352941, 0.03529412, 0.05490196]],\n",
       "\n",
       "       [[0.3372549 , 0.61960784, 0.94901961],\n",
       "        [0.34117647, 0.62352941, 0.95294118],\n",
       "        [0.34117647, 0.62352941, 0.95294118],\n",
       "        ...,\n",
       "        [0.03529412, 0.07058824, 0.07843137],\n",
       "        [0.03529412, 0.05882353, 0.0745098 ],\n",
       "        [0.03529412, 0.04705882, 0.06666667]],\n",
       "\n",
       "       [[0.34509804, 0.62745098, 0.95686275],\n",
       "        [0.34509804, 0.62745098, 0.95686275],\n",
       "        [0.34509804, 0.62745098, 0.95686275],\n",
       "        ...,\n",
       "        [0.03529412, 0.0745098 , 0.08235294],\n",
       "        [0.04313725, 0.06666667, 0.07843137],\n",
       "        [0.04313725, 0.05490196, 0.0745098 ]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[0.60392157, 0.6627451 , 0.58039216],\n",
       "        [0.58823529, 0.64705882, 0.56862745],\n",
       "        [0.59607843, 0.65098039, 0.58431373],\n",
       "        ...,\n",
       "        [0.42352941, 0.45098039, 0.38431373],\n",
       "        [0.43529412, 0.46666667, 0.40392157],\n",
       "        [0.45882353, 0.49411765, 0.42745098]],\n",
       "\n",
       "       [[0.58431373, 0.64313725, 0.55686275],\n",
       "        [0.61568627, 0.6745098 , 0.58823529],\n",
       "        [0.60392157, 0.6627451 , 0.58823529],\n",
       "        ...,\n",
       "        [0.38431373, 0.43529412, 0.4       ],\n",
       "        [0.43529412, 0.49019608, 0.43137255],\n",
       "        [0.44313725, 0.50196078, 0.43137255]],\n",
       "\n",
       "       [[0.56862745, 0.62745098, 0.5372549 ],\n",
       "        [0.58431373, 0.64313725, 0.55686275],\n",
       "        [0.57647059, 0.63529412, 0.55294118],\n",
       "        ...,\n",
       "        [0.32156863, 0.38823529, 0.36862745],\n",
       "        [0.37254902, 0.44313725, 0.40392157],\n",
       "        [0.40784314, 0.47843137, 0.42745098]]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "funded-lexington",
   "metadata": {},
   "source": [
    "# Load with DataLoader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "supreme-moldova",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "\n",
    "import torch\n",
    "from torchvision import datasets, transforms\n",
    "from torchvision.io import read_image\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision.transforms.functional import rgb_to_grayscale\n",
    "\n",
    "class DatasetImgs(Dataset):\n",
    "    def __init__(self, annotations_file, img_dir, label_dir, transform=None, target_transform=None):\n",
    "        self.img_labels = pd.read_csv(annotations_file)\n",
    "        self.img_dir = img_dir\n",
    "        self.label_dir = label_dir\n",
    "        self.transform = transform\n",
    "        self.target_transform = target_transform\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.img_labels)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])\n",
    "        image = Image.open(img_path)\n",
    "        #image = read_image(img_path)\n",
    "        label_path = os.path.join(self.label_dir, self.img_labels.iloc[idx, 1])\n",
    "        label = Image.open(label_path)\n",
    "        #label = read_image(label_path)\n",
    "        \n",
    "        \n",
    "        \n",
    "        # random flip - custom method\n",
    "        #image, label = transformImages(image, label)\n",
    "        \n",
    "        #compress\n",
    "        image, label = compress(image, label, rate=0.1)\n",
    "        \n",
    "        # TODO - transform\n",
    "        \n",
    "        \n",
    "        # convert to array\n",
    "        image, label = convert_to_array(image, label)\n",
    "        \n",
    "        if self.transform:\n",
    "            image = self.transform(image).cuda()\n",
    "        if self.target_transform:\n",
    "            label = self.target_transform(label).cuda()\n",
    "        \n",
    "        image = image.type(torch.FloatTensor)\n",
    "        label = label.type(torch.FloatTensor)\n",
    "        \n",
    "        sample = {\"image\": image, \"label\": label}\n",
    "        return sample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "reliable-theorem",
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 75\n",
    "VAL_BATCH_SIZE = 256\n",
    "TEST_BATCH_SIZE = 256\n",
    "SEED = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ancient-ethiopia",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(SEED)\n",
    "\n",
    "train_annotations_file = \"train.csv\"\n",
    "val_annotations_file = \"val.csv\"\n",
    "test_annotations_file = \"test.csv\"\n",
    "\n",
    "\n",
    "trainX_dir = \"bdd100k_images/images/100k/train\"\n",
    "trainY_dir = \"bdd100k_drivable_map/drivable_maps/color_labels/train\"\n",
    "\n",
    "valX_dir = \"bdd100k_images/images/100k/val\"\n",
    "valY_dir = \"bdd100k_drivable_map/drivable_maps/color_labels/val\"\n",
    "\n",
    "# transforms = transforms.Compose([transforms.RandomRotation(30),\n",
    "#                                 transforms.Resize((72, 128)),\n",
    "#                                 transforms.RandomHorizontalFlip(),\n",
    "#                                 transforms.ToTensor()])\n",
    "\n",
    "# transformsX = transforms.Compose([transforms.Resize((72, 128)),\n",
    "#                                 transforms.ToTensor()])\n",
    "# transformsY = transforms.Compose([transforms.Grayscale(),\n",
    "#                                 transforms.Resize((72, 128)),\n",
    "#                                 transforms.ToTensor()])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# train_dataset = DatasetImgs(train_annotations_file, trainX_dir, trainY_dir, transform=transformsX, target_transform=transformsY)\n",
    "# train_loader = DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "\n",
    "# val_dataset = DatasetImgs(val_annotations_file, valX_dir, valY_dir, transform=transformsX, target_transform=transformsY)\n",
    "# val_loader = DataLoader(dataset=train_dataset, batch_size=VAL_BATCH_SIZE, shuffle=True)\n",
    "\n",
    "# test_dataset = DatasetImgs(test_annotations_file, trainX_dir, trainY_dir, transform=transformsX, target_transform=transformsY)\n",
    "# test_loader = DataLoader(dataset=train_dataset, batch_size=TEST_BATCH_SIZE, shuffle=True)\n",
    "\n",
    "train_dataset = DatasetImgs(train_annotations_file, trainX_dir, trainY_dir, transform=transforms.ToTensor(), target_transform=transforms.ToTensor())\n",
    "train_loader = DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "\n",
    "val_dataset = DatasetImgs(val_annotations_file, valX_dir, valY_dir, transform=transforms.ToTensor(), target_transform=transforms.ToTensor())\n",
    "val_loader = DataLoader(dataset=train_dataset, batch_size=VAL_BATCH_SIZE, shuffle=True)\n",
    "\n",
    "test_dataset = DatasetImgs(test_annotations_file, trainX_dir, trainY_dir, transform=transforms.ToTensor(), target_transform=transforms.ToTensor())\n",
    "test_loader = DataLoader(dataset=train_dataset, batch_size=TEST_BATCH_SIZE, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "failing-catholic",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>nameX</th>\n",
       "      <th>nameY</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>79930740-a2e428ea.jpg</td>\n",
       "      <td>79930740-a2e428ea_drivable_color.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>832e2723-63312d1a.jpg</td>\n",
       "      <td>832e2723-63312d1a_drivable_color.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>89ee675b-bf40c5d9.jpg</td>\n",
       "      <td>89ee675b-bf40c5d9_drivable_color.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3c4403cc-15a4d350.jpg</td>\n",
       "      <td>3c4403cc-15a4d350_drivable_color.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4ee348f8-0887f45b.jpg</td>\n",
       "      <td>4ee348f8-0887f45b_drivable_color.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49995</th>\n",
       "      <td>58820efb-9ca3871a.jpg</td>\n",
       "      <td>58820efb-9ca3871a_drivable_color.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49996</th>\n",
       "      <td>029e1042-2639a5f8.jpg</td>\n",
       "      <td>029e1042-2639a5f8_drivable_color.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49997</th>\n",
       "      <td>4276675d-856280d0.jpg</td>\n",
       "      <td>4276675d-856280d0_drivable_color.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49998</th>\n",
       "      <td>a32543af-9207d709.jpg</td>\n",
       "      <td>a32543af-9207d709_drivable_color.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49999</th>\n",
       "      <td>359c8000-2be329f0.jpg</td>\n",
       "      <td>359c8000-2be329f0_drivable_color.png</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>50000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                       nameX                                 nameY\n",
       "0      79930740-a2e428ea.jpg  79930740-a2e428ea_drivable_color.png\n",
       "1      832e2723-63312d1a.jpg  832e2723-63312d1a_drivable_color.png\n",
       "2      89ee675b-bf40c5d9.jpg  89ee675b-bf40c5d9_drivable_color.png\n",
       "3      3c4403cc-15a4d350.jpg  3c4403cc-15a4d350_drivable_color.png\n",
       "4      4ee348f8-0887f45b.jpg  4ee348f8-0887f45b_drivable_color.png\n",
       "...                      ...                                   ...\n",
       "49995  58820efb-9ca3871a.jpg  58820efb-9ca3871a_drivable_color.png\n",
       "49996  029e1042-2639a5f8.jpg  029e1042-2639a5f8_drivable_color.png\n",
       "49997  4276675d-856280d0.jpg  4276675d-856280d0_drivable_color.png\n",
       "49998  a32543af-9207d709.jpg  a32543af-9207d709_drivable_color.png\n",
       "49999  359c8000-2be329f0.jpg  359c8000-2be329f0_drivable_color.png\n",
       "\n",
       "[50000 rows x 2 columns]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_labels = pd.read_csv(\"train.csv\")\n",
    "img_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "stuck-discipline",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(72, 128, 3)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tensor_image = read_image(\"bdd100k_images/images/100k/train/5a2a8521-8c9ea049.jpg\")\n",
    "tensor_image\n",
    "\n",
    "image = Image.open(\"bdd100k_images/images/100k/train/5a2a8521-8c9ea049.jpg\")\n",
    "image = image.resize([xSize, ySize])\n",
    "# convert to array\n",
    "image, label = convert_to_array(image, image)\n",
    "plt.imshow(label)\n",
    "image.shape\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "accredited-agreement",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3, 720, 1280])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f67c4dcc7d0>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch.nn.functional as F\n",
    "print(tensor_image.shape)\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from torchvision import transforms\n",
    "im = transforms.ToPILImage()(tensor_image).convert(\"RGB\")\n",
    "plt.imshow(im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "religious-marks",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "common-labor",
   "metadata": {},
   "outputs": [],
   "source": [
    "#out = F.interpolate(img, size=(72,128))\n",
    "\n",
    "# tensor_image = read_image(\"bdd100k_images/images/100k/train/5a2a8521-8c9ea049.jpg\")\n",
    "# tensor_image = tensor_image.unsqueeze(0)\n",
    "# out = F.interpolate(tensor_image, size=(72,128))\n",
    "# out = out.squeeze()\n",
    "# im = transforms.ToPILImage()(out).convert(\"RGB\")\n",
    "# plt.imshow(im)\n",
    "\n",
    "# t = transforms.Resize((72,128), interpolation=Image.BICUBIC)\n",
    "\n",
    "# out = t(tensor_image)\n",
    "# out = out.squeeze()\n",
    "# im = transforms.ToPILImage()(out).convert(\"RGB\")\n",
    "# plt.imshow(im)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "headed-killer",
   "metadata": {},
   "outputs": [],
   "source": [
    "# train_num = trainX.shape[0]\n",
    "# test_num = testX.shape[0]\n",
    "# x_dim = trainX.shape[2]\n",
    "# y_dim = trainX.shape[1]\n",
    "# val_num = valX.shape[0]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "silver-wisconsin",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "sorted-zealand",
   "metadata": {},
   "source": [
    "# Pytorch CNN Model\n",
    "\n",
    "Module is the baseclass for all NN module:\n",
    "https://pytorch.org/docs/stable/generated/torch.nn.Module.html\n",
    "\n",
    "### Conv2D -> \n",
    "Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros')\n",
    "https://cs231n.github.io/convolutional-networks/\n",
    "out_channels = number of kernels (filters) used, so dim in the 3rd dim\n",
    "\n",
    "\n",
    "### BatchNorm2d ->\n",
    "BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
    "Batch normalization normalizes the activations of the network between layers in batches so that the batches have a mean of 0 and a variance of 1.\n",
    "param = num of channels\n",
    "\n",
    "### nn.Linear ->\n",
    "Linear(in_features, out_features, bias=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "formal-scanning",
   "metadata": {},
   "source": [
    "### Convert to PyTorch types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "legislative-supervisor",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import torch\n",
    "# # train\n",
    "\n",
    "# trainX = trainX.reshape(train_num, 3, y_dim, x_dim).astype(float)\n",
    "# print(trainX[0])\n",
    "# print(trainX.shape)\n",
    "# trainX  = torch.from_numpy(trainX).type(torch.FloatTensor)\n",
    "\n",
    "# # trainY = trainY.reshape(train_num, 1, x_dim, y_dim).astype(float)\n",
    "# # trainY  = torch.from_numpy(trainY)\n",
    "# # print(trainY.shape)\n",
    "\n",
    "# trainY = trainY.reshape(train_num, 1, y_dim, x_dim).astype(float)\n",
    "# #trainY  = torch.from_numpy(trainY).type(torch.LongTensor)\n",
    "# trainY  = torch.from_numpy(trainY).type(torch.FloatTensor)\n",
    "# print(trainY.shape)\n",
    "\n",
    "\n",
    "\n",
    "# # val\n",
    "# valX = valX.reshape(val_num, 3, y_dim, x_dim).astype(float)\n",
    "# print(valX[0])\n",
    "# print(valX.shape)\n",
    "# valX  = torch.from_numpy(valX).type(torch.FloatTensor)\n",
    "\n",
    "# # valY = valY.reshape(val_num, 1, x_dim, y_dim).astype(float)\n",
    "# # valY  = torch.from_numpy(valY)\n",
    "\n",
    "\n",
    "# valY = valY.reshape(val_num, 1, y_dim, x_dim).astype(float)\n",
    "# #valY  = torch.from_numpy(valY).type(torch.LongTensor)\n",
    "# valY  = torch.from_numpy(valY).type(torch.FloatTensor)\n",
    "# # //TODO Test\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "perfect-limitation",
   "metadata": {},
   "outputs": [],
   "source": [
    "# trainX.shape, trainY.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "dimensional-slope",
   "metadata": {},
   "outputs": [],
   "source": [
    "# PyTorch libraries and modules\n",
    "#model 4\n",
    "\n",
    "import torch\n",
    "from torch.autograd import Variable\n",
    "from torch.nn import Linear, Softmax, Sigmoid, ReLU, NLLLoss, MSELoss, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout, Flatten\n",
    "from torch.optim import Adam, SGD\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch import optim\n",
    "\n",
    "modelRun = False\n",
    "storeImg = []\n",
    "\n",
    "class CNN(Module):\n",
    "    def __init__(self):\n",
    "        super(CNN,self).__init__() #base class for all neural network modules\n",
    "        input_chan = 3\n",
    "        out_chan_1 = 6 #before 3\n",
    "        out_chan_2 = 12 # before 5\n",
    "        out_chan_3 = 24\n",
    "        out_chan_4 = 48\n",
    "        \n",
    "        k_s_1 = 3\n",
    "        k_s_2 = 3\n",
    "        k_s_m = 2\n",
    "\n",
    "        \n",
    "        num_neurons_1 = 10\n",
    "        \n",
    "        output_size = 9216 #depending on num of pixels\n",
    "        \n",
    "        self.cnn_1 = Sequential(\n",
    "            # Defining a 2D convolution layer\n",
    "            Conv2d(input_chan, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "            #Sigmoid(),\n",
    "            Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            # Defining another 2D convolution layer\n",
    "        )\n",
    "        \n",
    "        self.cnn_2 = Sequential(\n",
    "            MaxPool2d(kernel_size=k_s_m, stride=1),\n",
    "            Conv2d(out_chan_1, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_2),\n",
    "            #Softmax(),\n",
    "            Conv2d(out_chan_2, out_chan_2, kernel_size=k_s_2, stride=1, padding=1), \n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_2),\n",
    "        )\n",
    "        \n",
    "        self.cnn_3 = Sequential(\n",
    "            MaxPool2d(kernel_size=k_s_m, stride=1),\n",
    "            Conv2d(out_chan_2, out_chan_3, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_3),\n",
    "            #Softmax(),\n",
    "            Conv2d(out_chan_3, out_chan_3, kernel_size=k_s_2, stride=1, padding=1), \n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_3),\n",
    "        )\n",
    "        \n",
    "        \n",
    "        self.pool_down_and_up = Sequential(\n",
    "            MaxPool2d(kernel_size=k_s_m, stride=1),\n",
    "            Conv2d(out_chan_3, out_chan_4, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_4),\n",
    "            #Softmax(),\n",
    "            Conv2d(out_chan_4, out_chan_4, kernel_size=k_s_2, stride=1, padding=1), \n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_4),\n",
    "            nn.ConvTranspose2d(out_chan_4,out_chan_3,kernel_size=k_s_m, stride=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_3)\n",
    "        )\n",
    "        \n",
    "        \n",
    "        self.up1 = Sequential (\n",
    "            Conv2d(out_chan_3+out_chan_3, out_chan_3, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_3),\n",
    "            Conv2d(out_chan_3, out_chan_3, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_3),\n",
    "            nn.ConvTranspose2d(out_chan_3,out_chan_2,kernel_size=k_s_m, stride=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_2),\n",
    "            #nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1)\n",
    "        )\n",
    "        \n",
    "        self.up2 = Sequential (\n",
    "\n",
    "            Conv2d(out_chan_2+out_chan_2, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_2),\n",
    "            Conv2d(out_chan_2, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_2),\n",
    "            nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_m, stride=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_1),     \n",
    "            \n",
    "            \n",
    "        )\n",
    "        \n",
    "        \n",
    "#         self.up3 = Sequential (\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_m, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "        \n",
    "        #one to one convolution\n",
    "        self.oneToOne = Sequential(\n",
    "            Conv2d(out_chan_1+out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(out_chan_1),\n",
    "            Conv2d(out_chan_1, 1, kernel_size=1, stride=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(1)\n",
    "\n",
    "        )\n",
    "        \n",
    "        \n",
    "        #functions used for helping show intermediate CNN output\n",
    "        self.set_dim_1 = Sequential(\n",
    "            Conv2d(out_chan_1, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(1),\n",
    "            \n",
    "        )\n",
    "        \n",
    "        self.set_dim_2 = Sequential(\n",
    "            Conv2d(out_chan_2, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "            ReLU(inplace=True),\n",
    "            BatchNorm2d(1),\n",
    "            \n",
    "        )\n",
    "        \n",
    "    #from tutorial - used for copy and cropping\n",
    "    def crop_and_concat(self, upsampled, bypass, crop=False):\n",
    "        if crop:\n",
    "            c = (bypass.size()[2] - upsampled.size()[2]) // 2\n",
    "            bypass = F.pad(bypass, (-c, -c, -c, -c))\n",
    "        return torch.cat((upsampled, bypass), 1)\n",
    "\n",
    "        \n",
    "        \n",
    "    # Defining the forward pass    \n",
    "    def forward(self, x):\n",
    "        if modelRun:\n",
    "            x1 = self.cnn_1(x)\n",
    "            \n",
    "            x1_reshape = self.set_dim_1(x1)\n",
    "            storeImg.append(x1_reshape.cpu().detach().numpy())\n",
    "            \n",
    "            x2 = self.cnn_2(x1)\n",
    "            \n",
    "            x2_reshape = self.set_dim_2(x2)\n",
    "            storeImg.append(x2_reshape.cpu().detach().numpy())\n",
    "            \n",
    "             #max pool -> down a layer\n",
    "            x3 = self.cnn_3(x2)\n",
    "            print(\"after cnn_3\")\n",
    "            print(x3.size())\n",
    "            \n",
    "            #max pool -> down a layer\n",
    "            x4 = self.pool_down_and_up(x3)\n",
    "            print(\"after cnn_4\")\n",
    "            print(x4.size())\n",
    "            # up-conv and back up a layer\n",
    "            x4 = self.crop_and_concat(x3, x4, crop=True)\n",
    "            \n",
    "            x = self.up1(x4)\n",
    "            print(\"after up_1\")\n",
    "            print(x.size())\n",
    "            # up-conv and back up a layer\n",
    "            \n",
    "            \n",
    "            x = self.crop_and_concat(x2, x, crop=True)\n",
    "            \n",
    "            x = self.up2(x)\n",
    "            print(\"after up_2\")\n",
    "            print(x.size()) \n",
    "            # up-conv and back up\n",
    "            \n",
    "            x = self.crop_and_concat(x1, x, crop=True)\n",
    "            \n",
    "            x = self.oneToOne(x)\n",
    "\n",
    "\n",
    "        \n",
    "        else:\n",
    "            x1 = self.cnn_1(x)\n",
    "            print(\"after cnn_1\")\n",
    "            print(x1.size())\n",
    "            \n",
    "            #max pool -> down a layer\n",
    "            x2 = self.cnn_2(x1) \n",
    "            print(\"after cnn_2\")\n",
    "            print(x2.size())\n",
    "            \n",
    "            #max pool -> down a layer\n",
    "            x3 = self.cnn_3(x2)\n",
    "            print(\"after cnn_3\")\n",
    "            print(x3.size())\n",
    "            \n",
    "            #max pool -> down a layer\n",
    "            x4 = self.pool_down_and_up(x3)\n",
    "            print(\"after cnn_4\")\n",
    "            print(x4.size())\n",
    "            # up-conv and back up a layer\n",
    "            x4 = self.crop_and_concat(x3, x4, crop=True)\n",
    "            \n",
    "            x = self.up1(x4)\n",
    "            print(\"after up_1\")\n",
    "            print(x.size())\n",
    "            # up-conv and back up a layer\n",
    "            \n",
    "            \n",
    "            x = self.crop_and_concat(x2, x, crop=True)\n",
    "            \n",
    "            x = self.up2(x)\n",
    "            print(\"after up_2\")\n",
    "            print(x.size()) \n",
    "            # up-conv and back up\n",
    "            \n",
    "            x = self.crop_and_concat(x1, x, crop=True)\n",
    "            \n",
    "            x = self.oneToOne(x)\n",
    "            \n",
    "            \n",
    "        return x\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "vulnerable-matter",
   "metadata": {},
   "source": [
    "#### Finding the correct dimension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "flying-material",
   "metadata": {},
   "outputs": [],
   "source": [
    "lr = 0.005\n",
    "# defining the model\n",
    "model = CNN()\n",
    "# defining the optimizer\n",
    "#optimizer =  torch.optim.SGD(model.parameters(), lr=lr, momentum=0.5, weight_decay=0.0005)\n",
    "#optimizer = optim.RMSprop(model.parameters(), lr=lr, weight_decay=1e-8, momentum=0.9)\n",
    "#optimizer = optim.RMSprop(model.parameters(), lr=lr, momentum=0.9)\n",
    "optimizer = Adam(model.parameters(), lr=0.00005)\n",
    "\n",
    "\n",
    "#scheduler - not used\n",
    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'max', patience=2) #changes the learning rate based on epoch\n",
    "\n",
    "\n",
    "# defining the loss function\n",
    "#criterion = MSELoss()\n",
    "#criterion = CrossEntropyLoss()\n",
    "#criterion = nn.BCEWithLogitsLoss()\n",
    "#criterion = nn.BCELoss()\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "\n",
    "# checking if GPU is available\n",
    "if torch.cuda.is_available():\n",
    "    model = model.cuda()\n",
    "    criterion = criterion.cuda()\n",
    "    \n",
    "# print(model)\n",
    "\n",
    "# trainX = trainX[:2].cuda()\n",
    "\n",
    "# output = model(Variable(trainX))\n",
    "# output\n",
    "\n",
    "\n",
    "\n",
    "def train(epoch, train_x, train_y, val_x, val_y):\n",
    "    model.train()\n",
    "    tr_loss = 0\n",
    "    # getting the training set\n",
    "    x_train, y_train = Variable(train_x), Variable(train_y)\n",
    "    # getting the validation set\n",
    "    #x_val, y_val = Variable(val_x), Variable(val_y)\n",
    "    # converting the data into GPU format\n",
    "    if torch.cuda.is_available():\n",
    "        x_train = x_train.cuda()\n",
    "        y_train = y_train.cuda()\n",
    "#         x_val = x_val.cuda()\n",
    "#         y_val = y_val.cuda()\n",
    "\n",
    "    # clearing the Gradients of the model parameters\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "    # prediction for training and validation set\n",
    "    output_train = model(x_train)\n",
    "    #output_val = model(x_val)\n",
    "\n",
    "    # computing the training and validation loss\n",
    "    print(output_train.shape)\n",
    "    print(y_train.shape)\n",
    "    loss_train = criterion(output_train, y_train)\n",
    "    #loss_val = criterion(output_val, y_val)\n",
    "    #train_losses.append(loss_train)\n",
    "    #val_losses.append(loss_val)\n",
    "    \n",
    "    batch_loss.append(loss_train)\n",
    "#     train_temp += loss_train\n",
    "    \n",
    "    # computing the updated weights of all the model parameters\n",
    "    loss_train.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    tr_loss = loss_train.item()\n",
    "    \n",
    "    #scheduler.step(tr_loss) #decreases the learning rate as we go\n",
    "    \n",
    "    \n",
    "#     if epoch%2 == 0:\n",
    "#         # printing the validation loss\n",
    "#         print('Epoch : ',epoch+1, '\\t', 'loss :', loss_val)\n",
    "     \n",
    "    # delete this things that aren't necessary for the next iteration\n",
    "#     del loss_train\n",
    "#     del loss_val\n",
    "#     del output_train\n",
    "#     del output_val\n",
    "    \n",
    "    return train_temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "possible-person",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#testing load of prev saved weights\n",
    "model.load_state_dict(torch.load(\"4epoch_model_param.pt\"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "understood-botswana",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([50, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([50, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([50, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([50, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([50, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([50, 6, 72, 128])\n",
      "torch.Size([50, 1, 72, 128])\n",
      "torch.Size([50, 1, 72, 128])\n",
      "Epoch :  1 \t loss : 0\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([75, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([75, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([75, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([75, 6, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "torch.Size([75, 1, 72, 128])\n",
      "after cnn_1\n",
      "torch.Size([50, 3, 72, 128])\n",
      "after cnn_2\n",
      "torch.Size([50, 12, 71, 127])\n",
      "after cnn_3\n",
      "torch.Size([50, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([50, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([50, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([50, 6, 72, 128])\n",
      "torch.Size([50, 1, 72, 128])\n",
      "torch.Size([50, 1, 72, 128])\n"
     ]
    }
   ],
   "source": [
    "# defining the number of epochs\n",
    "n_epochs = 2\n",
    "\n",
    "batch_loss = []\n",
    "# empty list to store training losses\n",
    "train_losses = []\n",
    "# empty list to store validation losses\n",
    "val_losses = []\n",
    "# training the model\n",
    "for epoch in range(n_epochs):\n",
    "    lossVal = 0\n",
    "    train_temp = 0\n",
    "    counter = 0\n",
    "    for batch in train_loader:\n",
    "        imgs = batch['image']\n",
    "        labels = batch['label']\n",
    "        train_temp += train(epoch, imgs, labels, valX, valY)\n",
    "        #loss_val += val\n",
    "#         if counter > 50:\n",
    "#             break\n",
    "        counter += 1\n",
    "        \n",
    "        \n",
    "    #val_losses.append(loss_val)\n",
    "    if epoch%2 == 0:\n",
    "        # printing the validation loss\n",
    "        print('Epoch : ',epoch+1, '\\t', 'loss :', train_temp)\n",
    "        \n",
    "    #torch.save(model.state_dict(), str(epoch) + \"epoch_model_param.pt\")\n",
    "    train_losses.append(train_temp)\n",
    "    #break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "following-wireless",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "torch.save(model.state_dict(), \"6epoch_model_param.pt\")\n",
    "import matplotlib.pyplot as plt \n",
    "plt.plot(batch_loss, label='Training loss')\n",
    "#plt.plot(val_losses, label='Validation loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "respiratory-arlington",
   "metadata": {},
   "outputs": [],
   "source": [
    "# torch.cuda.empty_cache()\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "powerful-executive",
   "metadata": {},
   "source": [
    "#discussion with Chau\n",
    "\n",
    "should label data be 0 and 1 per pixel rather than whatever it currently is?\n",
    "should we normalize all the images to be closer to 1 rather than such large numbers?\n",
    "should just discussion on loss function -> i think mseloss would be best for pixel by pixel comparison?\n",
    "should final output be filtered using something other than nerual network?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "forty-style",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'val_loader' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-9c082718ffc1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mfor\u001b[0m \u001b[0mbatch\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mval_loader\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m     \u001b[0mimgs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'image'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m     \u001b[0mlabels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'label'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'val_loader' is not defined"
     ]
    }
   ],
   "source": [
    "for batch in val_loader:\n",
    "    imgs = batch['image']\n",
    "    labels = batch['label']\n",
    "    break\n",
    "\n",
    "print(imgs.shape)\n",
    "print(imgs[0].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "elder-vehicle",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'imgs' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-4-f2e91d1700eb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mstoreImg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mtestSingle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mimgs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mimNum\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0mimNum\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mtestSingle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtestSingle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcuda\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m#testSingle = testSingle\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'imgs' is not defined"
     ]
    }
   ],
   "source": [
    "#imNum = 8\n",
    "\n",
    "imNum = 181\n",
    "modelRun = True\n",
    "storeImg = []\n",
    "\n",
    "testSingle = imgs[imNum:imNum+1]\n",
    "testSingle = testSingle.cuda()\n",
    "#testSingle = testSingle\n",
    "y_pred = model(testSingle)\n",
    "\n",
    "\n",
    "out = y_pred.cpu().detach().numpy()\n",
    "\n",
    "#print(valY[imNum].numpy().shape)\n",
    "\n",
    "# print(out)\n",
    "# print(\"Max:\")\n",
    "# print(np.max(out))\n",
    "avg = np.mean(out)\n",
    "print(avg)\n",
    "\n",
    "\n",
    "final = np.where(out > avg+6, 1, 0)\n",
    "\n",
    "\n",
    "final = np.reshape(final, (ySize,xSize))*255.0\n",
    "\n",
    "out = np.reshape(out, (ySize,xSize))\n",
    "\n",
    "#actual = ((np.reshape(labels[imNum].numpy(), (ySize, xSize)))*255)\n",
    "actual = labels[imNum]\n",
    "\n",
    "print(actual)\n",
    "\n",
    "print(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "final-findings",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-9ee6ea842758>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# im2 = Image.fromarray(actual.astype(np.uint8))\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# im2.show()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mavg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mavg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "# im = Image.fromarray((final).astype(np.uint8))\n",
    "# im.show()\n",
    "\n",
    "# im2 = Image.fromarray(actual.astype(np.uint8))\n",
    "# im2.show()\n",
    "avg = np.mean(out)\n",
    "print(avg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "mineral-forward",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'actual' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-fc94cc317049>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mactual\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"Greys\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'actual' is not defined"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.imshow(actual.numpy()[0],cmap=\"Greys\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "id": "religious-disclosure",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f674e2b8290>"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(out, cmap=\"Greys\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "id": "closing-baghdad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f674e29eb90>"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plt.imshow(np.reshape(imgs[imNum], (ySize,xSize,3)))\n",
    "#type(imgs[imNum])\n",
    "\n",
    "plt.imshow(imgs[imNum].permute(1, 2, 0)  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "id": "documented-firmware",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f674e21a450>"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(final, cmap=\"Greys\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "mighty-representation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.21704638, -0.21704638, -0.21704638, ..., -0.21704638,\n",
       "        -0.21704638, -0.21704638],\n",
       "       [-0.21704638, -0.21704638, -0.21704638, ..., -0.21704638,\n",
       "        -0.21704638, -0.21704638],\n",
       "       [-0.21704638, -0.21704638, -0.21704638, ..., -0.21704638,\n",
       "        -0.21704638, -0.21704638],\n",
       "       ...,\n",
       "       [-0.21704638, -0.21704638, -0.21704638, ..., -0.09844863,\n",
       "        -0.21704638, -0.21704638],\n",
       "       [-0.21704638, -0.21704638, -0.21704638, ..., -0.21704638,\n",
       "        -0.21704638, -0.05774039],\n",
       "       [-0.21704638, -0.21704638,  0.4344882 , ...,  0.6244258 ,\n",
       "         0.66834915,  0.39602867]], dtype=float32)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#plt.imshow(np.reshape(valX[imNum].numpy(), (ySize,xSize,3)), cmap=\"Greys\")\n",
    "storeImg[0][0][0].shape\n",
    "np.resize(storeImg[0][0][0], (ySize,xSize))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "aware-headline",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f67c5138d50>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(np.resize(storeImg[0][0][0], (ySize,xSize)), cmap=\"Greys\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "neither-karaoke",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f67c4c1fd90>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(np.resize(storeImg[1][0][0], (ySize,xSize)), cmap=\"Greys\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "hybrid-imperial",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81863\n",
      "Batch Loss: 0.15544\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81256\n",
      "Batch Loss: 0.14964\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81549\n",
      "Batch Loss: 0.13845\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80783\n",
      "Batch Loss: 0.15095\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81808\n",
      "Batch Loss: 0.15199\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81532\n",
      "Batch Loss: 0.14854\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81408\n",
      "Batch Loss: 0.14321\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81166\n",
      "Batch Loss: 0.13860\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80667\n",
      "Batch Loss: 0.14757\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81153\n",
      "Batch Loss: 0.13359\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82117\n",
      "Batch Loss: 0.14443\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81361\n",
      "Batch Loss: 0.14862\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81720\n",
      "Batch Loss: 0.15100\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82130\n",
      "Batch Loss: 0.14913\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.79970\n",
      "Batch Loss: 0.14838\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82307\n",
      "Batch Loss: 0.14328\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81479\n",
      "Batch Loss: 0.14476\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81368\n",
      "Batch Loss: 0.13715\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81892\n",
      "Batch Loss: 0.13744\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81571\n",
      "Batch Loss: 0.15206\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81569\n",
      "Batch Loss: 0.14347\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81241\n",
      "Batch Loss: 0.13631\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81462\n",
      "Batch Loss: 0.14355\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80599\n",
      "Batch Loss: 0.15481\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80494\n",
      "Batch Loss: 0.15073\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81428\n",
      "Batch Loss: 0.13958\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81464\n",
      "Batch Loss: 0.14643\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81804\n",
      "Batch Loss: 0.14306\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81590\n",
      "Batch Loss: 0.14488\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81148\n",
      "Batch Loss: 0.15531\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80953\n",
      "Batch Loss: 0.13848\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81406\n",
      "Batch Loss: 0.16252\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81086\n",
      "Batch Loss: 0.13951\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81586\n",
      "Batch Loss: 0.14348\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80917\n",
      "Batch Loss: 0.14306\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81296\n",
      "Batch Loss: 0.15000\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80999\n",
      "Batch Loss: 0.15168\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82794\n",
      "Batch Loss: 0.14803\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch Accuracy 0.82458\n",
      "Batch Loss: 0.14474\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80414\n",
      "Batch Loss: 0.15110\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81515\n",
      "Batch Loss: 0.14827\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81560\n",
      "Batch Loss: 0.15158\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80746\n",
      "Batch Loss: 0.14482\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80426\n",
      "Batch Loss: 0.15113\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82740\n",
      "Batch Loss: 0.14610\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80128\n",
      "Batch Loss: 0.15043\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81288\n",
      "Batch Loss: 0.14979\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81669\n",
      "Batch Loss: 0.14433\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81491\n",
      "Batch Loss: 0.14444\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81372\n",
      "Batch Loss: 0.14185\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81358\n",
      "Batch Loss: 0.14795\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81652\n",
      "Batch Loss: 0.13835\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80961\n",
      "Batch Loss: 0.14194\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80996\n",
      "Batch Loss: 0.15290\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81851\n",
      "Batch Loss: 0.14194\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80989\n",
      "Batch Loss: 0.13966\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81580\n",
      "Batch Loss: 0.14669\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81948\n",
      "Batch Loss: 0.13499\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81340\n",
      "Batch Loss: 0.14730\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81170\n",
      "Batch Loss: 0.14322\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82616\n",
      "Batch Loss: 0.14700\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80720\n",
      "Batch Loss: 0.15223\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81147\n",
      "Batch Loss: 0.15038\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81333\n",
      "Batch Loss: 0.15080\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80886\n",
      "Batch Loss: 0.14808\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81315\n",
      "Batch Loss: 0.14008\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81454\n",
      "Batch Loss: 0.14182\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81396\n",
      "Batch Loss: 0.14674\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81689\n",
      "Batch Loss: 0.15133\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81313\n",
      "Batch Loss: 0.14111\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82629\n",
      "Batch Loss: 0.13698\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81246\n",
      "Batch Loss: 0.15020\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80817\n",
      "Batch Loss: 0.14763\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81805\n",
      "Batch Loss: 0.14459\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81515\n",
      "Batch Loss: 0.13715\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81076\n",
      "Batch Loss: 0.15060\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81691\n",
      "Batch Loss: 0.14642\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch Accuracy 0.81457\n",
      "Batch Loss: 0.14221\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80573\n",
      "Batch Loss: 0.14557\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81898\n",
      "Batch Loss: 0.14563\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81700\n",
      "Batch Loss: 0.14462\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81168\n",
      "Batch Loss: 0.15152\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82066\n",
      "Batch Loss: 0.14809\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81566\n",
      "Batch Loss: 0.14130\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80142\n",
      "Batch Loss: 0.15123\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81167\n",
      "Batch Loss: 0.15091\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81177\n",
      "Batch Loss: 0.14754\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81924\n",
      "Batch Loss: 0.14644\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80973\n",
      "Batch Loss: 0.15161\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82262\n",
      "Batch Loss: 0.15275\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81177\n",
      "Batch Loss: 0.14918\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81249\n",
      "Batch Loss: 0.14768\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82012\n",
      "Batch Loss: 0.14551\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81351\n",
      "Batch Loss: 0.14181\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81162\n",
      "Batch Loss: 0.13563\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81809\n",
      "Batch Loss: 0.14362\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81832\n",
      "Batch Loss: 0.15162\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81202\n",
      "Batch Loss: 0.13458\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81463\n",
      "Batch Loss: 0.13576\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81258\n",
      "Batch Loss: 0.14040\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80957\n",
      "Batch Loss: 0.14689\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80674\n",
      "Batch Loss: 0.14253\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81817\n",
      "Batch Loss: 0.14759\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80918\n",
      "Batch Loss: 0.14860\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82336\n",
      "Batch Loss: 0.15160\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81074\n",
      "Batch Loss: 0.14432\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81761\n",
      "Batch Loss: 0.14430\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80930\n",
      "Batch Loss: 0.14373\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82285\n",
      "Batch Loss: 0.13600\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80478\n",
      "Batch Loss: 0.15442\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80770\n",
      "Batch Loss: 0.14016\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81978\n",
      "Batch Loss: 0.14762\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81128\n",
      "Batch Loss: 0.14890\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81094\n",
      "Batch Loss: 0.13495\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81231\n",
      "Batch Loss: 0.14270\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80415\n",
      "Batch Loss: 0.14136\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch Accuracy 0.81617\n",
      "Batch Loss: 0.14283\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80797\n",
      "Batch Loss: 0.13756\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81598\n",
      "Batch Loss: 0.14417\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82198\n",
      "Batch Loss: 0.15266\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81014\n",
      "Batch Loss: 0.14038\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80595\n",
      "Batch Loss: 0.13554\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80836\n",
      "Batch Loss: 0.15088\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81188\n",
      "Batch Loss: 0.14652\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82059\n",
      "Batch Loss: 0.14439\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81127\n",
      "Batch Loss: 0.14648\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81501\n",
      "Batch Loss: 0.14124\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82033\n",
      "Batch Loss: 0.13779\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81777\n",
      "Batch Loss: 0.13469\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81663\n",
      "Batch Loss: 0.14290\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81106\n",
      "Batch Loss: 0.14828\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81223\n",
      "Batch Loss: 0.14529\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80348\n",
      "Batch Loss: 0.15339\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80943\n",
      "Batch Loss: 0.14503\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81575\n",
      "Batch Loss: 0.14627\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81853\n",
      "Batch Loss: 0.13919\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80060\n",
      "Batch Loss: 0.14419\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81358\n",
      "Batch Loss: 0.14566\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81973\n",
      "Batch Loss: 0.13771\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81567\n",
      "Batch Loss: 0.13586\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82610\n",
      "Batch Loss: 0.13943\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81779\n",
      "Batch Loss: 0.14465\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80957\n",
      "Batch Loss: 0.13736\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80706\n",
      "Batch Loss: 0.14557\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81263\n",
      "Batch Loss: 0.14717\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82031\n",
      "Batch Loss: 0.14516\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81035\n",
      "Batch Loss: 0.13827\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80588\n",
      "Batch Loss: 0.14546\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81773\n",
      "Batch Loss: 0.14506\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81620\n",
      "Batch Loss: 0.14074\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81787\n",
      "Batch Loss: 0.13931\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81929\n",
      "Batch Loss: 0.14363\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81571\n",
      "Batch Loss: 0.14165\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80878\n",
      "Batch Loss: 0.14000\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81242\n",
      "Batch Loss: 0.14825\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch Accuracy 0.81282\n",
      "Batch Loss: 0.14210\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80434\n",
      "Batch Loss: 0.13634\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80735\n",
      "Batch Loss: 0.14687\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81783\n",
      "Batch Loss: 0.14434\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80540\n",
      "Batch Loss: 0.14562\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81765\n",
      "Batch Loss: 0.13755\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82618\n",
      "Batch Loss: 0.13705\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80799\n",
      "Batch Loss: 0.14418\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82101\n",
      "Batch Loss: 0.14320\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81436\n",
      "Batch Loss: 0.15530\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82352\n",
      "Batch Loss: 0.13602\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81811\n",
      "Batch Loss: 0.14266\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81978\n",
      "Batch Loss: 0.13644\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82218\n",
      "Batch Loss: 0.14157\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81016\n",
      "Batch Loss: 0.15170\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81513\n",
      "Batch Loss: 0.14414\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81692\n",
      "Batch Loss: 0.14142\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81615\n",
      "Batch Loss: 0.14453\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81114\n",
      "Batch Loss: 0.13973\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82066\n",
      "Batch Loss: 0.13764\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80721\n",
      "Batch Loss: 0.14588\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81916\n",
      "Batch Loss: 0.15295\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80406\n",
      "Batch Loss: 0.14532\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81364\n",
      "Batch Loss: 0.14877\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80088\n",
      "Batch Loss: 0.14011\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81535\n",
      "Batch Loss: 0.14189\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81403\n",
      "Batch Loss: 0.14319\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82122\n",
      "Batch Loss: 0.14098\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80917\n",
      "Batch Loss: 0.13992\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81711\n",
      "Batch Loss: 0.13893\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81352\n",
      "Batch Loss: 0.14996\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80446\n",
      "Batch Loss: 0.14662\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81628\n",
      "Batch Loss: 0.14441\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80974\n",
      "Batch Loss: 0.14288\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80954\n",
      "Batch Loss: 0.14777\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.80451\n",
      "Batch Loss: 0.14988\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81236\n",
      "Batch Loss: 0.14119\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.81671\n",
      "Batch Loss: 0.15464\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n",
      "Batch Accuracy 0.82201\n",
      "Batch Loss: 0.14283\n",
      "after cnn_3\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([256, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([256, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([256, 6, 72, 128])\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch Accuracy 0.81506\n",
      "Batch Loss: 0.14518\n",
      "after cnn_3\n",
      "torch.Size([80, 24, 70, 126])\n",
      "after cnn_4\n",
      "torch.Size([80, 24, 70, 126])\n",
      "after up_1\n",
      "torch.Size([80, 12, 71, 127])\n",
      "after up_2\n",
      "torch.Size([80, 6, 72, 128])\n",
      "Batch Accuracy 0.82031\n",
      "Batch Loss: 0.14660\n"
     ]
    }
   ],
   "source": [
    "def val_accuracy(val_loader, model):\n",
    "    val_loss = 0\n",
    "    accuracy = 0\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        label1_sum = 0\n",
    "        pixel_count = 0\n",
    "        batch_count = 0\n",
    "        for batch in val_loader:\n",
    "            imgs = batch['image']\n",
    "            labels = batch['label']\n",
    "            #img, labels = imgs.to(device), labels.to(device)  ## for GPU\n",
    "            \n",
    "            imgs, labels = Variable(imgs), Variable(labels)\n",
    "            # getting the validation set\n",
    "            #x_val, y_val = Variable(val_x), Variable(val_y)\n",
    "            # converting the data into GPU format\n",
    "            if torch.cuda.is_available():\n",
    "                imgs = imgs.cuda()\n",
    "                labels = labels.cuda()\n",
    "            \n",
    "            predictions = model.forward(imgs)\n",
    "            batch_loss = criterion(predictions, labels)\n",
    "            val_loss += batch_loss.item()\n",
    "            val_losses.append(batch_loss.item())\n",
    "\n",
    "            ps = torch.exp(predictions)\n",
    "            top_p, top_class = ps.topk(1, dim=1)\n",
    "            equals = (top_class == labels.view(*top_class.shape))\n",
    "\n",
    "#             plt.imshow(equals[0,:, :, :].numpy().reshape((72, 128)))\n",
    "#             plt.show()\n",
    "            #accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
    "            label1_sum += equals.cpu().numpy().sum()\n",
    "\n",
    "            pixel_count += np.prod(equals.size())\n",
    "#             val_loss = val_loss/len(val_loader)\n",
    "#             val_accuracy = accuracy/len(val_loader)\n",
    "            print(\"Batch Accuracy {:.5f}\".format(equals.cpu().numpy().mean()))\n",
    "            print(f\"Batch Loss: {batch_loss.item():.5f}\")\n",
    "            batch_count+=1\n",
    "\n",
    "#             print(f\"Validation loss: {val_loss:.5f}.. \"\n",
    "#                   f\"Validation accuracy: {val_accuracy:.5f}\")\n",
    "            #yield test_loss, accuracy\n",
    "        return label1_sum / pixel_count, val_loss / batch_count, val_losses\n",
    "#this is how I call it\n",
    "#accuracy, avg_val_loss, val_losses = val_accuracy(test_loader, model)\n",
    "test_accuracy, avg_test_loss, test_losses = val_accuracy(test_loader, model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "clean-treasurer",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy\n",
      "0.8138010069444445\n",
      "Avg Val Loss\n",
      "0.1447456022914575\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy\")\n",
    "print(accuracy)\n",
    "print(\"Avg Val Loss\")\n",
    "print(avg_val_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "sublime-luxembourg",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy\n",
      "0.8138010069444445\n",
      "Avg Test Loss\n",
      "0.14477347263268062\n"
     ]
    }
   ],
   "source": [
    "print(\"Test Accuracy\")\n",
    "print(test_accuracy)\n",
    "print(\"Avg Test Loss\")\n",
    "print(avg_test_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "unsigned-shakespeare",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Works really well!!!! Model 1 as referred to in the progress tracker 03/15\n",
    "# # PyTorch libraries and modules\n",
    "# import torch\n",
    "# from torch.autograd import Variable\n",
    "# from torch.nn import Linear, Softmax, Sigmoid, ReLU, NLLLoss, MSELoss, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout, Flatten\n",
    "# from torch.optim import Adam, SGD\n",
    "# import torch.nn as nn\n",
    "# import torch.nn.functional as F\n",
    "# from torch import optim\n",
    "\n",
    "# modelRun = False\n",
    "# storeImg = []\n",
    "\n",
    "# class CNN(Module):\n",
    "#     def __init__(self):\n",
    "#         super(CNN,self).__init__() #base class for all neural network modules\n",
    "#         out_chan_1 = 3\n",
    "#         out_chan_2 = 7\n",
    "#         k_s_1 = 3\n",
    "#         k_s_2 = 3\n",
    "\n",
    "        \n",
    "#         num_neurons_1 = 10\n",
    "        \n",
    "#         output_size = 9216 #depending on num of pixels\n",
    "        \n",
    "#         self.cnn_1 = Sequential(\n",
    "#             # Defining a 2D convolution layer\n",
    "#             Conv2d(3, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "#             #Sigmoid(),\n",
    "            \n",
    "#             MaxPool2d(kernel_size=k_s_1, stride=1),\n",
    "#             # Defining another 2D convolution layer\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_2 = Sequential(\n",
    "#             Conv2d(out_chan_1, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_2),\n",
    "#             #Softmax(),\n",
    "            \n",
    "#             MaxPool2d(kernel_size=k_s_2, stride=1)\n",
    "#         )\n",
    "#         self.up1 = Sequential (\n",
    "#             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "            \n",
    "            \n",
    "#             #nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1)\n",
    "#         )\n",
    "        \n",
    "#         self.up2 = Sequential (\n",
    "#             nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         #one to one convolution\n",
    "#         self.oneToOne = Sequential(\n",
    "#             nn.ConvTranspose2d(out_chan_1,1,kernel_size=1, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         #functions used for helping show intermediate CNN output\n",
    "#         self.set_dim_1 = Sequential(\n",
    "#             Conv2d(out_chan_1, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "#         self.set_dim_2 = Sequential(\n",
    "#             Conv2d(out_chan_2, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "#         #from tutorial - used for copy and cropping\n",
    "#         def crop_and_concat(self, upsampled, bypass, crop=False):\n",
    "#             if crop:\n",
    "#                 c = (bypass.size()[2] - upsampled.size()[2]) // 2\n",
    "#                 bypass = F.pad(bypass, (-c, -c, -c, -c))\n",
    "#             return torch.cat((upsampled, bypass), 1)\n",
    "\n",
    "        \n",
    "        \n",
    "#     # Defining the forward pass    \n",
    "#     def forward(self, x):\n",
    "#         if modelRun:\n",
    "#             x1 = self.cnn_1(x)\n",
    "            \n",
    "#             x1_reshape = self.set_dim_1(x1)\n",
    "#             storeImg.append(x1_reshape.cpu().detach().numpy())\n",
    "            \n",
    "#             x2 = self.cnn_2(x1)\n",
    "            \n",
    "#             x2_reshape = self.set_dim_2(x2)\n",
    "#             storeImg.append(x2_reshape.cpu().detach().numpy())\n",
    "            \n",
    "#             x3 = self.up1(x2)\n",
    "            \n",
    "#             x = self.up2(x3)\n",
    "            \n",
    "#             x = self.oneToOne(x)\n",
    "\n",
    "\n",
    "        \n",
    "#         else:\n",
    "#             x = self.cnn_1(x)\n",
    "#             print(\"after cnn_1\")\n",
    "#             print(x.size())\n",
    "#             x = self.cnn_2(x)\n",
    "#             print(\"after cnn_2\")\n",
    "#             print(x.size())\n",
    "#             x = self.up1(x)\n",
    "#             print(\"after up_1\")\n",
    "#             print(x.size())     \n",
    "#             x = self.up2(x)\n",
    "#             print(\"after up_1\")\n",
    "#             print(x.size())   \n",
    "            \n",
    "#             x = self.oneToOne(x)\n",
    "            \n",
    "            \n",
    "#         return x\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "respective-tongue",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "governmental-viewer",
   "metadata": {},
   "outputs": [],
   "source": [
    "# RUNS FINE\n",
    "# # PyTorch libraries and modules\n",
    "# import torch\n",
    "# from torch.autograd import Variable\n",
    "# from torch.nn import Linear, Softmax, Sigmoid, ReLU, NLLLoss, MSELoss, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout, Flatten\n",
    "# from torch.optim import Adam, SGD\n",
    "# import torch.nn as nn\n",
    "# import torch.nn.functional as F\n",
    "# from torch import optim\n",
    "\n",
    "# modelRun = False\n",
    "# storeImg = []\n",
    "\n",
    "# class CNN(Module):\n",
    "#     def __init__(self):\n",
    "#         super(CNN,self).__init__() #base class for all neural network modules\n",
    "#         out_chan_1 = 3\n",
    "#         out_chan_2 = 7\n",
    "#         k_s_1 = 3\n",
    "#         k_s_2 = 3\n",
    "\n",
    "        \n",
    "#         num_neurons_1 = 10\n",
    "        \n",
    "#         output_size = 9216 #depending on num of pixels\n",
    "        \n",
    "#         self.cnn_1 = Sequential(\n",
    "#             # Defining a 2D convolution layer\n",
    "#             Conv2d(3, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "#             BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "#             #Sigmoid(),\n",
    "#             ReLU(inplace=True),\n",
    "#             MaxPool2d(kernel_size=k_s_1, stride=1),\n",
    "#             # Defining another 2D convolution layer\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_2 = Sequential(\n",
    "#             Conv2d(out_chan_1, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_2),\n",
    "#             #Softmax(),\n",
    "#             ReLU(inplace=True),\n",
    "#             MaxPool2d(kernel_size=k_s_2, stride=1)\n",
    "#         )\n",
    "#         self.up1 = Sequential (\n",
    "#             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "#             nn.ConvTranspose2d(out_chan_1,1,kernel_size=k_s_2, stride=1),\n",
    "#             BatchNorm2d(1),\n",
    "#             ReLU(inplace=True),\n",
    "            \n",
    "#             #nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1)\n",
    "#         )\n",
    "        \n",
    "#         #functions used for helping show intermediate CNN output\n",
    "#         self.set_dim_1 = Sequential(\n",
    "#             Conv2d(out_chan_1, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "#             BatchNorm2d(1),\n",
    "#             ReLU(inplace=True)\n",
    "#         )\n",
    "        \n",
    "#         self.set_dim_2 = Sequential(\n",
    "#             Conv2d(out_chan_2, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "#             BatchNorm2d(1),\n",
    "#             ReLU(inplace=True)\n",
    "#         )\n",
    "        \n",
    "        \n",
    "        \n",
    "#     # Defining the forward pass    \n",
    "#     def forward(self, x):\n",
    "#         if modelRun:\n",
    "#             x1 = self.cnn_1(x)\n",
    "            \n",
    "#             x1_reshape = self.set_dim_1(x1)\n",
    "#             storeImg.append(x1_reshape.cpu().detach().numpy())\n",
    "            \n",
    "#             x2 = self.cnn_2(x1)\n",
    "            \n",
    "#             x2_reshape = self.set_dim_2(x2)\n",
    "#             storeImg.append(x2_reshape.cpu().detach().numpy())\n",
    "            \n",
    "#             x = self.up1(x2)\n",
    "\n",
    "\n",
    "        \n",
    "#         else:\n",
    "#             x = self.cnn_1(x)\n",
    "#             print(x.size())\n",
    "#             x = self.cnn_2(x)\n",
    "#             print(x.size())\n",
    "#             x = self.up1(x)\n",
    "            \n",
    "#         return x\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "permanent-waters",
   "metadata": {},
   "outputs": [],
   "source": [
    "# class CNN(Module):\n",
    "#     def __init__(self):\n",
    "#         super(CNN,self).__init__() #base class for all neural network modules\n",
    "#         out_chan_1 = 5\n",
    "#         out_chan_2 = 7\n",
    "#         out_chan_3 = 3\n",
    "#         k_s_1 = 3\n",
    "#         k_s_2 = 3\n",
    "# #         k_s_1_mp = 2 #mp = max pool\n",
    "# #         k_s_2_mp = 2\n",
    "        \n",
    "#         num_neurons_1 = 10\n",
    "        \n",
    "#         output_size = 9216 #depending on num of pixels\n",
    "        \n",
    "#         self.cnn_1 = Sequential(\n",
    "#             # Defining a 2D convolution layer\n",
    "#             Conv2d(3, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "#             BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "#             ReLU(inplace=True),\n",
    "# #             MaxPool2d(kernel_size=k_s_1, stride=1),\n",
    "#             # Defining another 2D convolution layer\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_1, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_2 = Sequential(\n",
    "#             MaxPool2d(kernel_size=k_s_1, stride=2), #downscale\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "#             #MaxPool2d(kernel_size=k_s_2, stride=1),\n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         self.cnn_3 = Sequential(\n",
    "#             MaxPool2d(kernel_size=k_s_2, stride=2), #downscale\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "#             #MaxPool2d(kernel_size=k_s_2, stride=1),\n",
    "#         )\n",
    "        \n",
    "        \n",
    "        \n",
    "        \n",
    "# #         self.up_2 = Sequential (\n",
    "# #             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1)\n",
    "# #             #nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1)\n",
    "# #         )\n",
    "        \n",
    "        \n",
    "#         self.up_1 = Sequential(\n",
    "#             #Conv2d(out_chan_3, 1, kernel_size=1, stride=1, padding=1),\n",
    "#             #nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             #Sigmoid(),\n",
    "#             nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=2), #upscale\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "            \n",
    "# #             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=2),\n",
    "# #             nn.ConvTranspose2d(out_chan_1,1,kernel_size=k_s_1, stride=1)\n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         self.up_2 = Sequential(\n",
    "#             #Conv2d(out_chan_3, 1, kernel_size=1, stride=1, padding=1),\n",
    "#             #nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             #Sigmoid(),\n",
    "#             nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_1, stride=2), #upscale\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             ReLU(inplace=True),\n",
    "#             Conv2d(out_chan_1, 1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(1),\n",
    "#             ReLU(inplace=True),\n",
    "            \n",
    "# #             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=2),\n",
    "# #             nn.ConvTranspose2d(out_chan_1,1,kernel_size=k_s_1, stride=1)\n",
    "#         )\n",
    "        \n",
    "#         self.out_conv = Sequential(\n",
    "#             Conv2d(1, 1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(1),\n",
    "#             ReLU(inplace=True),\n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         self.set_chan = Sequential(\n",
    "#             Conv2d(5, 1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(1),\n",
    "#             ReLU(inplace=True)\n",
    "#         )\n",
    "        \n",
    "#         self.set_dim = Sequential(\n",
    "#             Conv2d(5, 1,kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             BatchNorm2d(1),\n",
    "#             ReLU(inplace=True)\n",
    "#         )\n",
    "        \n",
    "        \n",
    "# #         self.up_3 = Sequential(\n",
    "# #             #Conv2d(out_chan_3, 1, kernel_size=1, stride=1, padding=1),\n",
    "# #             #nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "# #             #Sigmoid(),\n",
    "# #             nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_1, stride=2),\n",
    "# #             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "# #             BatchNorm2d(out_chan_1),\n",
    "# #             ReLU(inplace=True),\n",
    "# #             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "# #             BatchNorm2d(out_chan_1),\n",
    "# #             ReLU(inplace=True),\n",
    "            \n",
    "# # #             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=2),\n",
    "# # #             nn.ConvTranspose2d(out_chan_1,1,kernel_size=k_s_1, stride=1)\n",
    "# #         )\n",
    "        \n",
    "        \n",
    "# #         self.linear_layers = Sequential(\n",
    "# #             Linear(out_chan_2 * 31 * 17, num_neurons_1),\n",
    "# #             Softmax(dim=1),\n",
    "# #             #ReLU(inplace=True),\n",
    "# #             Linear(num_neurons_1,output_size),\n",
    "# #             Sigmoid() # map from 0 to 1\n",
    "# #             #Softmax(dim=1)\n",
    "# #             #Sign()\n",
    "# #             #ReLU(inplace=True)\n",
    "            \n",
    "# #         )\n",
    "        \n",
    "#     # Defining the forward pass    \n",
    "#     def forward(self, x):\n",
    "#         if modelRun:\n",
    "#             print(\"Start: \")\n",
    "#             print(x.size())\n",
    "\n",
    "#             x1 = self.cnn_1(x)\n",
    "\n",
    "#             print(\"1st Conv: \")\n",
    "#             print(x1.size())\n",
    "#             print(\"shape:\")\n",
    "#             print((x1).cpu().detach().numpy().shape)\n",
    "#             x1_reshape = self.set_dim(x1)\n",
    "#             storeImg.append(x1_reshape.cpu().detach().numpy())\n",
    "            \n",
    "#             x2 = self.cnn_2(x1)\n",
    "\n",
    "#             print(\"2nd Conv: \")\n",
    "#             print(x2.size())\n",
    "#             x2_reshape = self.set_dim(x2)\n",
    "#             storeImg.append(x2_reshape.cpu().detach().numpy())\n",
    "\n",
    "#             x3 = self.cnn_3(x2)\n",
    "#             print(\"3rd Conv: \")\n",
    "#             print(x3.size())\n",
    "#             x3_reshape = self.set_dim(x3)\n",
    "#             storeImg.append(x3_reshape.cpu().detach().numpy())\n",
    "\n",
    "#     #         x1 = x2+x1\n",
    "\n",
    "#             x4 = self.up_1(x3)\n",
    "\n",
    "#             print(\"Upscale 1: \")\n",
    "#             print(x4.size())\n",
    "\n",
    "#             #x4 = x4 + x2\n",
    "\n",
    "#             x5 = self.up_2(x4)\n",
    "\n",
    "#             print(\"Upscale 2: \")\n",
    "#             print(x5.size())\n",
    "\n",
    "\n",
    "\n",
    "#             diffY = x1.size()[2] - x5.size()[2]\n",
    "#             diffX = x1.size()[3] - x5.size()[3]\n",
    "#             x5 = F.pad(x5, [diffX//2, diffX - diffX//2,\n",
    "#                            diffY//2, diffY - diffY//2])\n",
    "#             x6 = torch.cat([x1, x5], dim=1)\n",
    "\n",
    "\n",
    "#             #x1 = self.set_chan(x1)\n",
    "#             #x5 = x5 + x1\n",
    "\n",
    "#             x6 = self.out_conv(x5)\n",
    "#             print(\"Out: \")\n",
    "#             print(x6.size())\n",
    "#         else:\n",
    "#             #print(\"Start: \")\n",
    "#             #print(x.size())\n",
    "\n",
    "#             x1 = self.cnn_1(x)\n",
    "#             x1_reshape = self.set_dim(x1)\n",
    "\n",
    "#             #print(\"1st Conv: \")\n",
    "#             #print(x1.size())\n",
    "\n",
    "#             x2 = self.cnn_2(x1)\n",
    "\n",
    "#             #print(\"2nd Conv: \")\n",
    "#             #print(x2.size())\n",
    "\n",
    "\n",
    "#             x3 = self.cnn_3(x2)\n",
    "# #            print(\"3rd Conv: \")\n",
    "# #            print(x3.size())\n",
    "\n",
    "#     #         x1 = x2+x1\n",
    "\n",
    "#             x4 = self.up_1(x3)\n",
    "\n",
    "# #            print(\"Upscale 1: \")\n",
    "# #            print(x4.size())\n",
    "\n",
    "#             #x4 = x4 + x2\n",
    "\n",
    "#             x5 = self.up_2(x4)\n",
    "\n",
    "# #            print(\"Upscale 2: \")\n",
    "# #            print(x5.size())\n",
    "\n",
    "\n",
    "\n",
    "#             diffY = x1.size()[2] - x5.size()[2]\n",
    "#             diffX = x1.size()[3] - x5.size()[3]\n",
    "#             x5 = F.pad(x5, [diffX//2, diffX - diffX//2,\n",
    "#                            diffY//2, diffY - diffY//2])\n",
    "#             x6 = torch.cat([x1, x5], dim=1)\n",
    "\n",
    "\n",
    "#             #x1 = self.set_chan(x1)\n",
    "#             #x5 = x5 + x1\n",
    "\n",
    "#             x6 = self.out_conv(x5)\n",
    "#             #print(\"Out: \")\n",
    "#             #print(x6.size())\n",
    "        \n",
    "# #         x3 = self.up_1(x2)\n",
    "# #         print(x3.size())\n",
    "        \n",
    "#         #x2 = x1 + x2\n",
    "        \n",
    "#         #x1 = x3 + x1\n",
    "#         #print(x2.size())\n",
    "# #         x = self.output(x)\n",
    "#         #x=x.long()\n",
    "#         #x = x.view(x.size(0), -1)\n",
    "        \n",
    "#         #x = self.linear_layers(x)\n",
    "#         #x = x.float()\n",
    "#         return x6\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sensitive-certificate",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "hawaiian-implementation",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Model 2 - works with bypass layer\n",
    "# # PyTorch libraries and modules\n",
    "# import torch\n",
    "# from torch.autograd import Variable\n",
    "# from torch.nn import Linear, Softmax, Sigmoid, ReLU, NLLLoss, MSELoss, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout, Flatten\n",
    "# from torch.optim import Adam, SGD\n",
    "# import torch.nn as nn\n",
    "# import torch.nn.functional as F\n",
    "# from torch import optim\n",
    "\n",
    "# modelRun = False\n",
    "# storeImg = []\n",
    "\n",
    "# class CNN(Module):\n",
    "#     def __init__(self):\n",
    "#         super(CNN,self).__init__() #base class for all neural network modules\n",
    "#         out_chan_1 = 3\n",
    "#         out_chan_2 = 7\n",
    "#         k_s_1 = 3\n",
    "#         k_s_2 = 3\n",
    "\n",
    "        \n",
    "#         num_neurons_1 = 10\n",
    "        \n",
    "#         output_size = 9216 #depending on num of pixels\n",
    "        \n",
    "#         self.cnn_1 = Sequential(\n",
    "#             # Defining a 2D convolution layer\n",
    "#             Conv2d(3, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "#             #Sigmoid(),\n",
    "            \n",
    "#             MaxPool2d(kernel_size=k_s_1, stride=1),\n",
    "#             # Defining another 2D convolution layer\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_2 = Sequential(\n",
    "#             Conv2d(out_chan_1, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_2),\n",
    "#             #Softmax(),\n",
    "            \n",
    "#             MaxPool2d(kernel_size=k_s_2, stride=1)\n",
    "#         )\n",
    "#         self.up1 = Sequential (\n",
    "#             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "            \n",
    "            \n",
    "#             #nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1)\n",
    "#         )\n",
    "        \n",
    "#         self.up2 = Sequential (\n",
    "#             nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         #one to one convolution\n",
    "#         self.oneToOne = Sequential(\n",
    "#             nn.ConvTranspose2d(6,1,kernel_size=1, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(1),\n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         #functions used for helping show intermediate CNN output\n",
    "#         self.set_dim_1 = Sequential(\n",
    "#             Conv2d(out_chan_1, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "#         self.set_dim_2 = Sequential(\n",
    "#             Conv2d(out_chan_2, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "#     #from tutorial - used for copy and cropping\n",
    "#     def crop_and_concat(self, upsampled, bypass, crop=False):\n",
    "#         if crop:\n",
    "#             c = (bypass.size()[2] - upsampled.size()[2]) // 2\n",
    "#             bypass = F.pad(bypass, (-c, -c, -c, -c))\n",
    "#         return torch.cat((upsampled, bypass), 1)\n",
    "\n",
    "        \n",
    "        \n",
    "#     # Defining the forward pass    \n",
    "#     def forward(self, x):\n",
    "#         if modelRun:\n",
    "#             x1 = self.cnn_1(x)\n",
    "            \n",
    "#             x1_reshape = self.set_dim_1(x1)\n",
    "#             storeImg.append(x1_reshape.cpu().detach().numpy())\n",
    "            \n",
    "#             x2 = self.cnn_2(x1)\n",
    "            \n",
    "#             x2_reshape = self.set_dim_2(x2)\n",
    "#             storeImg.append(x2_reshape.cpu().detach().numpy())\n",
    "            \n",
    "#             x3 = self.up1(x2)\n",
    "            \n",
    "#             x = self.up2(x3)\n",
    "            \n",
    "#             x = self.crop_and_concat(x, x1, crop=True)\n",
    "            \n",
    "#             x = self.oneToOne(x)\n",
    "\n",
    "\n",
    "        \n",
    "#         else:\n",
    "#             x1 = self.cnn_1(x)\n",
    "#             print(\"after cnn_1\")\n",
    "#             print(x.size())\n",
    "#             x = self.cnn_2(x1)\n",
    "#             print(\"after cnn_2\")\n",
    "#             print(x.size())\n",
    "#             x = self.up1(x)\n",
    "#             print(\"after up_1\")\n",
    "#             print(x.size())     \n",
    "#             x = self.up2(x)\n",
    "#             print(\"after up_1\")\n",
    "#             print(x.size())   \n",
    "            \n",
    "#             x = self.crop_and_concat(x, x1, crop=True)\n",
    "            \n",
    "#             x = self.oneToOne(x)\n",
    "            \n",
    "            \n",
    "#         return x\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "animal-taxation",
   "metadata": {},
   "outputs": [],
   "source": [
    "# PyTorch libraries and modules\n",
    "# Model 3 - more convolutions in each layer\n",
    "# import torch\n",
    "# from torch.autograd import Variable\n",
    "# from torch.nn import Linear, Softmax, Sigmoid, ReLU, NLLLoss, MSELoss, CrossEntropyLoss, Sequential, Conv2d, MaxPool2d, Module, Softmax, BatchNorm2d, Dropout, Flatten\n",
    "# from torch.optim import Adam, SGD\n",
    "# import torch.nn as nn\n",
    "# import torch.nn.functional as F\n",
    "# from torch import optim\n",
    "\n",
    "# modelRun = False\n",
    "# storeImg = []\n",
    "\n",
    "# class CNN(Module):\n",
    "#     def __init__(self):\n",
    "#         super(CNN,self).__init__() #base class for all neural network modules\n",
    "#         out_chan_1 = 5 #before 3\n",
    "#         out_chan_2 = 9 # before 5\n",
    "#         k_s_1 = 3\n",
    "#         k_s_2 = 3\n",
    "\n",
    "        \n",
    "#         num_neurons_1 = 10\n",
    "        \n",
    "#         output_size = 9216 #depending on num of pixels\n",
    "        \n",
    "#         self.cnn_1 = Sequential(\n",
    "#             # Defining a 2D convolution layer\n",
    "#             Conv2d(3, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1), #just specify the num of output channels\n",
    "#             #Sigmoid(),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_1, stride=1, padding=1), \n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             MaxPool2d(kernel_size=k_s_1, stride=1),\n",
    "#             # Defining another 2D convolution layer\n",
    "#         )\n",
    "        \n",
    "#         self.cnn_2 = Sequential(\n",
    "#             Conv2d(out_chan_1, out_chan_2, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_2),\n",
    "#             #Softmax(),\n",
    "#             Conv2d(out_chan_2, out_chan_2, kernel_size=k_s_2, stride=1, padding=1), \n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_2),\n",
    "#             MaxPool2d(kernel_size=k_s_2, stride=1)\n",
    "#         )\n",
    "#         self.up1 = Sequential (\n",
    "#             nn.ConvTranspose2d(out_chan_2,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "            \n",
    "#             #nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1)\n",
    "#         )\n",
    "        \n",
    "#         self.up2 = Sequential (\n",
    "#             nn.ConvTranspose2d(out_chan_1,out_chan_1,kernel_size=k_s_2, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "#             Conv2d(out_chan_1, out_chan_1, kernel_size=k_s_2, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(out_chan_1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         #one to one convolution\n",
    "#         self.oneToOne = Sequential(\n",
    "#             nn.ConvTranspose2d(10,1,kernel_size=1, stride=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(1),\n",
    "#         )\n",
    "        \n",
    "        \n",
    "#         #functions used for helping show intermediate CNN output\n",
    "#         self.set_dim_1 = Sequential(\n",
    "#             Conv2d(out_chan_1, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "#         self.set_dim_2 = Sequential(\n",
    "#             Conv2d(out_chan_2, 1,kernel_size=k_s_1, stride=1, padding=1),\n",
    "#             ReLU(inplace=True),\n",
    "#             BatchNorm2d(1),\n",
    "            \n",
    "#         )\n",
    "        \n",
    "#     #from tutorial - used for copy and cropping\n",
    "#     def crop_and_concat(self, upsampled, bypass, crop=False):\n",
    "#         if crop:\n",
    "#             c = (bypass.size()[2] - upsampled.size()[2]) // 2\n",
    "#             bypass = F.pad(bypass, (-c, -c, -c, -c))\n",
    "#         return torch.cat((upsampled, bypass), 1)\n",
    "\n",
    "        \n",
    "        \n",
    "#     # Defining the forward pass    \n",
    "#     def forward(self, x):\n",
    "#         if modelRun:\n",
    "#             x1 = self.cnn_1(x)\n",
    "            \n",
    "#             x1_reshape = self.set_dim_1(x1)\n",
    "#             storeImg.append(x1_reshape.cpu().detach().numpy())\n",
    "            \n",
    "#             x2 = self.cnn_2(x1)\n",
    "            \n",
    "#             x2_reshape = self.set_dim_2(x2)\n",
    "#             storeImg.append(x2_reshape.cpu().detach().numpy())\n",
    "            \n",
    "#             x3 = self.up1(x2)\n",
    "            \n",
    "#             x = self.up2(x3)\n",
    "            \n",
    "#             x = self.crop_and_concat(x, x1, crop=True)\n",
    "            \n",
    "#             x = self.oneToOne(x)\n",
    "\n",
    "\n",
    "        \n",
    "#         else:\n",
    "#             x1 = self.cnn_1(x)\n",
    "#             print(\"after cnn_1\")\n",
    "#             print(x.size())\n",
    "#             x = self.cnn_2(x1)\n",
    "#             print(\"after cnn_2\")\n",
    "#             print(x.size())\n",
    "#             x = self.up1(x)\n",
    "#             print(\"after up_1\")\n",
    "#             print(x.size())     \n",
    "#             x = self.up2(x)\n",
    "#             print(\"after up_1\")\n",
    "#             print(x.size())   \n",
    "            \n",
    "#             x = self.crop_and_concat(x, x1, crop=True)\n",
    "            \n",
    "#             x = self.oneToOne(x)\n",
    "            \n",
    "            \n",
    "#         return x\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "delayed-colleague",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.7.9 (default, Aug 18 2020, 06:24:24) \n",
      "[GCC 5.4.0 20160609]\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "norman-oriental",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}