Deep_Complex_U_net.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Deep Complex U-net.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyPyFLDkOLr0oOTkZpflWpKl",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mehdihosseinimoghadam/Complex-Neural-Networks/blob/main/Deep_Complex_U_net.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "NZPxUl5yrPV1"
      },
      "outputs": [],
      "source": [
        "from torch import nn\n",
        "import torch"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class CLinear(nn.Module):\n",
        "  def __init__(self, in_channels, out_channels, **kwargs):\n",
        "    super(CLinear, self).__init__()\n",
        "    self.in_channels = in_channels\n",
        "    self.out_channels = out_channels\n",
        "\n",
        "    self.re_linear = nn.Linear(self.in_channels, self.out_channels, **kwargs)\n",
        "    self.im_linear = nn.Linear(self.in_channels, self.out_channels, **kwargs)\n",
        "\n",
        "    nn.init.xavier_uniform_(self.re_linear.weight)\n",
        "    nn.init.xavier_uniform_(self.im_linear.weight)\n",
        "\n",
        "\n",
        "\n",
        "  def forward(self, x):  \n",
        "    x_re = x[..., 0]\n",
        "    x_im = x[..., 1]\n",
        "\n",
        "    out_re = self.re_linear(x_re) - self.im_linear(x_im)\n",
        "    out_im = self.re_linear(x_im) + self.im_linear(x_re)\n",
        "\n",
        "    out = torch.stack([out_re, out_im], -1) \n",
        "\n",
        "    return out"
      ],
      "metadata": {
        "id": "-ymA9WFTXf6v"
      },
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CConv2d(nn.Module):\n",
        "  def __init__(self, in_channels, out_channels, **kwargs):\n",
        "    super(CConv2d, self).__init__()\n",
        "    self.in_channels = in_channels\n",
        "    self.out_channels = out_channels\n",
        "\n",
        "\n",
        "    self.re_conv = nn.Conv2d(self.in_channels, self.out_channels, **kwargs)\n",
        "    self.im_conv = nn.Conv2d(self.in_channels, self.out_channels, **kwargs)\n",
        "\n",
        "    nn.init.xavier_uniform_(self.re_conv.weight)\n",
        "    nn.init.xavier_uniform_(self.im_conv.weight)\n",
        "\n",
        "  def forward(self, x):  \n",
        "    x_re = x[..., 0]\n",
        "    x_im = x[..., 1]\n",
        "\n",
        "    out_re = self.re_conv(x_re) - self.im_conv(x_im)\n",
        "    out_im = self.re_conv(x_im) + self.im_conv(x_re)\n",
        "\n",
        "    out = torch.stack([out_re, out_im], -1) \n",
        "\n",
        "    return out\n"
      ],
      "metadata": {
        "id": "-ACZSe4arcbG"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CConvTrans2d(nn.Module):\n",
        "  def __init__(self, in_channels, out_channels, **kwargs):\n",
        "    super(CConvTrans2d, self).__init__()\n",
        "    self.in_channels = in_channels\n",
        "    self.out_channels = out_channels\n",
        "\n",
        "\n",
        "    self.re_Tconv = nn.ConvTranspose2d(self.in_channels, self.out_channels, **kwargs)\n",
        "    self.im_Tconv = nn.ConvTranspose2d(self.in_channels, self.out_channels, **kwargs)\n",
        "\n",
        "    nn.init.xavier_uniform_(self.re_Tconv.weight)\n",
        "    nn.init.xavier_uniform_(self.im_Tconv.weight)\n",
        "\n",
        "\n",
        "  def forward(self, x):  \n",
        "    x_re = x[..., 0]\n",
        "    x_im = x[..., 1]\n",
        "\n",
        "    out_re = self.re_Tconv(x_re) - self.im_Tconv(x_im)\n",
        "    out_im = self.re_Tconv(x_im) + self.im_Tconv(x_re)\n",
        "\n",
        "    out = torch.stack([out_re, out_im], -1) \n",
        "\n",
        "    return out"
      ],
      "metadata": {
        "id": "rAFkSP1BvOFn"
      },
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CBatchnorm(nn.Module):\n",
        "    def __init__(self, in_channels):\n",
        "        super(CBatchnorm, self).__init__()\n",
        "        self.in_channels = in_channels\n",
        "\n",
        "        self.re_batch = nn.BatchNorm2d(in_channels)\n",
        "        self.im_batch = nn.BatchNorm2d(in_channels)\n",
        "\n",
        "\n",
        "    def forward(self, x):\n",
        "        x_re = x[..., 0]\n",
        "        x_im = x[..., 1]\n",
        "\n",
        "        out_re =  self.re_batch(x_re)\n",
        "        out_im =  self.re_batch(x_im)\n",
        "\n",
        "\n",
        "        out = torch.stack([out_re, out_im], -1) \n",
        "\n",
        "        return out\n",
        "\n"
      ],
      "metadata": {
        "id": "TolGeNh3xO0z"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CconvBlock(nn.Module):\n",
        "  def __init__(self, in_channels, out_channels, **kwargs):\n",
        "    super(CconvBlock, self).__init__()\n",
        "    self.in_channels = in_channels\n",
        "    self.out_channels = out_channels\n",
        "\n",
        "    self.CConv2d = CConv2d(self.in_channels, self.out_channels, **kwargs)\n",
        "    self.CBatchnorm = CBatchnorm(self.out_channels)\n",
        "    self.leaky_relu = nn.LeakyReLU()\n",
        "\n",
        "\n",
        "  def forward(self, x):\n",
        "    print(1)\n",
        "    conved = self.CConv2d(x)\n",
        "    print(2)\n",
        "    normed = self.CBatchnorm(conved)\n",
        "    print(3)\n",
        "    activated =  self.leaky_relu(normed)\n",
        "\n",
        "    return activated\n",
        "\n"
      ],
      "metadata": {
        "id": "rhkZ62u9zI7Z"
      },
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CConvTransBlock(nn.Module):\n",
        "  def __init__(self, in_channels, out_channels, last_layer=False, **kwargs):\n",
        "    super(CConvTransBlock, self).__init__()\n",
        "    self.in_channels = in_channels\n",
        "    self.out_channels = out_channels\n",
        "    self.last_layer = last_layer\n",
        "\n",
        "    self.CConvTrans2d = CConvTrans2d(self.in_channels, self.out_channels, **kwargs)\n",
        "    self.CBatchnorm = CBatchnorm(self.out_channels)\n",
        "    self.leaky_relu = nn.LeakyReLU()\n",
        "\n",
        "\n",
        "  def forward(self, x):\n",
        "    conved =  self.CConvTrans2d(x)\n",
        "\n",
        "    if not self.last_layer:\n",
        "        normed = self.CBatchnorm(conved)\n",
        "        activated =  self.leaky_relu(normed)\n",
        "        return activated\n",
        "    else:\n",
        "        m_phase = conved/(torch.abs(conved)+1e-8)  \n",
        "        m_mag = torch.tanh(torch.abs(conved))\n",
        "        out = m_phase * m_mag\n",
        "        return out  \n"
      ],
      "metadata": {
        "id": "ne9KCvIm6nOv"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Encoder(nn.Module):\n",
        "  def __init__(self):\n",
        "      super(Encoder, self).__init__()\n",
        "\n",
        "      self.CconvBlock0 = CconvBlock(filter_size=(7,5), stride_size=(2,2), in_channels=1, out_channels=45, padding=(0,0))\n",
        "      self.CconvBlock1 = CconvBlock(filter_size=(7,5), stride_size=(2,2), in_channels=45, out_channels=90, padding=(0,0))\n",
        "      self.CconvBlock2 = CconvBlock(filter_size=(5,3), stride_size=(2,2), in_channels=90, out_channels=90, padding=(0,0))\n",
        "      self.CconvBlock3 = CconvBlock(filter_size=(5,3), stride_size=(2,2), in_channels=90, out_channels=90, padding=(0,0))\n",
        "      self.CconvBlock4 = CconvBlock(filter_size=(5,3), stride_size=(2,1), in_channels=90, out_channels=90, padding=(0,0))\n",
        "\n",
        "\n",
        "  def forward(self, x):\n",
        "      ccb0 = self.CconvBlock0(x)\n",
        "      ccb1 = self.CconvBlock1(ccb0) \n",
        "      ccb2 = self.CconvBlock2(ccb1)        \n",
        "      ccb3 = self.CconvBlock3(ccb2)        \n",
        "      ccb4 = self.CconvBlock4(ccb3)\n",
        "\n",
        "      return [ccb0, ccb1, ccb2, ccb3, ccb4]"
      ],
      "metadata": {
        "id": "C97FsXBhEZJz"
      },
      "execution_count": 28,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Decoder(nn.Module):\n",
        "  def __init__(self, n_fft=64, hop_length=16):\n",
        "    super(Decoder, self).__init__()\n",
        "    self.n_fft = n_fft\n",
        "    self.hop_length = hop_length\n",
        "\n",
        "\n",
        "    self.CConvTransBlock0 = CConvTransBlock(filter_size=(5,3), stride_size=(2,1), in_channels=90, out_channels=90, output_padding=(0,0), padding=(0,0))\n",
        "    self.CConvTransBlock1 = CConvTransBlock(filter_size=(5,3), stride_size=(2,2), in_channels=180, out_channels=90, output_padding=(0,0), padding=(0,0))\n",
        "    self.CConvTransBlock2 = CConvTransBlock(filter_size=(5,3), stride_size=(2,2), in_channels=180, out_channels=90, output_padding=(0,0), padding=(0,0))\n",
        "    self.CConvTransBlock3 = CConvTransBlock(filter_size=(7,5), stride_size=(2,2), in_channels=180, out_channels=45, output_padding=(0,0), padding=(0,0))\n",
        "    self.CConvTransBlock4 = CConvTransBlock(filter_size=(7,5), stride_size=(2,2), in_channels=90, output_padding=(0,1), padding=(0,0),\n",
        "                              out_channels=1, last_layer=True)\n",
        "    \n",
        "\n",
        "  def forward(self, x0, x, is_istft=True):\n",
        "\n",
        "    \n",
        "        cctb0 = self.CConvTransBlock0(x[-1])\n",
        "        # skip-connection\n",
        "        c0 = torch.cat((cctb0, x[-2]), dim=1)\n",
        "        \n",
        "        cctb1 = self.CConvTransBlock1(c0)\n",
        "        c1 = torch.cat((cctb1, x[-3]), dim=1)\n",
        "        \n",
        "        cctb2 = self.CConvTransBlock2(c1)\n",
        "        c2 = torch.cat((cctb2, x[-4]), dim=1)\n",
        "        \n",
        "        cctb3 = self.CConvTransBlock3(c2)\n",
        "        c3 = torch.cat((cctb3, x[-5]), dim=1)\n",
        "        \n",
        "        cctb4 = self.CConvTransBlock4(c3)\n",
        "\n",
        "\n",
        "        output = cctb4 * x0\n",
        "        if is_istft:\n",
        "            output = torch.squeeze(output, 1)\n",
        "            output = torch.istft(output, n_fft=self.n_fft, hop_length=self.hop_length, normalized=True)\n",
        "        \n",
        "        return output\n"
      ],
      "metadata": {
        "id": "mrYxCS-5Id71"
      },
      "execution_count": 29,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Model(nn.Module):\n",
        "  def __init__(self, encoder_out, n_fft=64, hop_length=16):\n",
        "    super(Model, self).__init__()\n",
        "    self.encoder_out = encoder_out\n",
        "    self.n_fft = n_fft\n",
        "    self.hop_length = hop_length\n",
        "\n",
        "    self.Encoder = Encoder()\n",
        "    self.Decoder = Decoder(self.encoder_out, self.n_fft, self.hop_length)\n",
        "\n",
        "  def forward(self, x):\n",
        "      encoded = self.Encoder(x)\n",
        "      decoded = self.Decoder(x, encoded) \n",
        "      return decoded"
      ],
      "metadata": {
        "id": "72uMa77DNI3y"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "CConv2d1 = CConv2d(in_channels = 1, out_channels = 2, kernel_size = (2,2), stride = (1,1), padding = (0,0))"
      ],
      "metadata": {
        "id": "Tkyyf0CefdEX"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Complex Linear Layer Test"
      ],
      "metadata": {
        "id": "5wJjo5ttYhbS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x0 = torch.randn(5,)\n",
        "x1 = torch.randn(5,)\n",
        "x = torch.stack([x0,x1],-1)\n",
        "x = x.unsqueeze(0)\n",
        "x.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JGztKrafYm6H",
        "outputId": "dd8d933e-30d5-42fa-adde-a9cdb39c2e08"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([1, 5, 2])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "CLinear1 = CLinear(5, 20)\n",
        "CLinear1(x)\n",
        "print(x.shape)\n",
        "print(CLinear1(x))\n",
        "print(CLinear1(x).shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ueyP8epiYzz2",
        "outputId": "e66bebe5-56f6-45a6-c275-ff9aff5a4b5a"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 5, 2])\n",
            "tensor([[[ 2.3109, -1.0268],\n",
            "         [ 0.1623, -0.9172],\n",
            "         [ 0.3190, -1.2287],\n",
            "         [-0.2733,  1.0967],\n",
            "         [ 1.5082,  0.7720],\n",
            "         [-0.0378, -0.7488],\n",
            "         [-0.2157, -0.3021],\n",
            "         [ 0.5175,  0.4255],\n",
            "         [ 1.1525,  0.2468],\n",
            "         [-0.6438, -0.1749],\n",
            "         [ 0.3438,  0.8782],\n",
            "         [ 0.8914,  0.0172],\n",
            "         [ 0.7914,  0.7718],\n",
            "         [ 1.2767,  1.2431],\n",
            "         [ 0.4427,  0.1786],\n",
            "         [ 1.4706, -0.0756],\n",
            "         [-0.5609,  1.6882],\n",
            "         [ 1.0263,  1.0759],\n",
            "         [ 0.3197, -1.4567],\n",
            "         [ 1.4837, -0.2569]]], grad_fn=<StackBackward0>)\n",
            "torch.Size([1, 20, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Complex Convolution Tests"
      ],
      "metadata": {
        "id": "8obTO6u9YbBn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x0 = torch.randn(5,5)\n",
        "x1 = torch.randn(5,5)\n",
        "x = torch.stack([x0,x1],-1)\n",
        "x = x.unsqueeze(0)\n",
        "x = x.unsqueeze(0)"
      ],
      "metadata": {
        "id": "daLABWV0f65s"
      },
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.shape)\n",
        "print(CConv2d1(x))\n",
        "print(CConv2d1(x).shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MVuBXXOkgzkH",
        "outputId": "cf3e54a1-5851-490b-d8d3-334a6569c907"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 1, 5, 5, 2])\n",
            "tensor([[[[[-0.2341,  0.0716],\n",
            "           [ 0.3865, -0.8192],\n",
            "           [-1.3823, -0.6631],\n",
            "           [-1.8096, -0.9856]],\n",
            "\n",
            "          [[-0.8186, -3.8495],\n",
            "           [-2.0101, -0.4146],\n",
            "           [-0.1466, -0.1537],\n",
            "           [ 1.0804, -0.3110]],\n",
            "\n",
            "          [[ 0.0705, -0.0787],\n",
            "           [-2.3859, -2.2655],\n",
            "           [-1.0929,  1.6646],\n",
            "           [ 1.0593, -1.4782]],\n",
            "\n",
            "          [[ 0.1098, -0.9718],\n",
            "           [ 0.3863, -0.8386],\n",
            "           [-0.7495,  0.3499],\n",
            "           [-0.5392, -2.6627]]],\n",
            "\n",
            "\n",
            "         [[[ 0.7597,  1.4941],\n",
            "           [ 0.1508,  0.6988],\n",
            "           [-1.4712, -0.9276],\n",
            "           [ 0.5946,  0.7313]],\n",
            "\n",
            "          [[ 0.8548,  0.8320],\n",
            "           [ 1.4564, -0.3194],\n",
            "           [-0.7587,  0.4565],\n",
            "           [ 1.1803,  1.2750]],\n",
            "\n",
            "          [[ 0.2698,  1.3152],\n",
            "           [-0.1428,  1.3002],\n",
            "           [ 0.6749,  2.2751],\n",
            "           [ 0.3063,  1.2067]],\n",
            "\n",
            "          [[-1.8984,  1.0157],\n",
            "           [ 0.3635,  1.3501],\n",
            "           [-1.0483, -0.4257],\n",
            "           [ 1.1574, -0.0789]]]]], grad_fn=<StackBackward0>)\n",
            "torch.Size([1, 2, 4, 4, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "CConvTrans2d1 = CConvTrans2d(in_channels = 1, out_channels = 2, kernel_size = (2,2), stride = (1,1), padding = (0,0))"
      ],
      "metadata": {
        "id": "08euZDR-jGXM"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.shape)\n",
        "print(CConvTrans2d1(x))\n",
        "print(CConvTrans2d1(x).shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bDXvCIEvjcwf",
        "outputId": "c240bdad-b8f2-4e8b-a322-a83017094e1d"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 1, 5, 5, 2])\n",
            "tensor([[[[[-0.5543,  0.4390],\n",
            "           [-0.2612,  0.8152],\n",
            "           [-0.0586,  0.7387],\n",
            "           [ 0.0968, -0.7288],\n",
            "           [ 0.5347,  0.5047],\n",
            "           [-0.4359,  0.4578]],\n",
            "\n",
            "          [[ 0.7379,  1.4173],\n",
            "           [ 0.0898,  0.0964],\n",
            "           [-0.5463,  0.0163],\n",
            "           [-2.6312,  0.7264],\n",
            "           [-0.3534, -0.4425],\n",
            "           [-0.3940,  0.4020]],\n",
            "\n",
            "          [[-1.2603, -0.8353],\n",
            "           [ 0.1504, -0.2374],\n",
            "           [ 0.1259, -0.6706],\n",
            "           [ 1.4613,  1.6072],\n",
            "           [ 0.4606,  1.5097],\n",
            "           [-0.7338,  0.9787]],\n",
            "\n",
            "          [[ 0.2797,  2.1281],\n",
            "           [-2.3418,  1.0650],\n",
            "           [-1.1543,  2.3451],\n",
            "           [-0.3229,  0.2800],\n",
            "           [-0.5932, -1.0071],\n",
            "           [-0.5940,  0.3839]],\n",
            "\n",
            "          [[ 0.0170, -0.6591],\n",
            "           [-0.5761,  0.3649],\n",
            "           [ 0.4268, -0.0229],\n",
            "           [-1.4475, -0.4828],\n",
            "           [ 0.4071, -0.4063],\n",
            "           [-0.2501,  0.7546]],\n",
            "\n",
            "          [[-0.7438,  0.0076],\n",
            "           [-0.4503,  0.1118],\n",
            "           [-1.0376, -0.1113],\n",
            "           [-0.1443,  1.1274],\n",
            "           [-0.8557,  0.4020],\n",
            "           [-0.5870,  0.4450]]],\n",
            "\n",
            "\n",
            "         [[[ 0.3209, -0.0928],\n",
            "           [-0.0053, -0.6517],\n",
            "           [-0.7383, -0.2483],\n",
            "           [-0.8596,  1.3112],\n",
            "           [ 0.8853,  0.5025],\n",
            "           [-0.0886,  0.2773]],\n",
            "\n",
            "          [[-0.4538, -0.9909],\n",
            "           [-1.4788,  1.0144],\n",
            "           [ 0.6185,  1.0330],\n",
            "           [ 1.4316, -0.4589],\n",
            "           [ 1.0897, -1.1915],\n",
            "           [ 0.1840,  0.4130]],\n",
            "\n",
            "          [[ 1.7393,  0.7034],\n",
            "           [-0.5682, -0.7265],\n",
            "           [-0.5301,  2.7398],\n",
            "           [ 0.4136,  0.3949],\n",
            "           [-1.0760, -1.8742],\n",
            "           [-1.0399,  0.8043]],\n",
            "\n",
            "          [[-0.1938, -1.4410],\n",
            "           [ 0.0044, -1.1159],\n",
            "           [-0.4595, -2.2728],\n",
            "           [ 0.1944,  0.7354],\n",
            "           [ 0.8195,  0.5177],\n",
            "           [ 0.0411,  0.7418]],\n",
            "\n",
            "          [[ 0.9336,  0.7990],\n",
            "           [-0.4618,  0.6579],\n",
            "           [-0.3451, -0.1269],\n",
            "           [ 0.2338,  1.7912],\n",
            "           [ 0.7149, -0.9736],\n",
            "           [ 0.1852,  1.0395]],\n",
            "\n",
            "          [[ 0.7329,  0.0030],\n",
            "           [ 0.1676,  0.3478],\n",
            "           [ 1.0166, -0.1918],\n",
            "           [-1.0215, -0.2328],\n",
            "           [ 1.0467, -0.7731],\n",
            "           [ 0.2103,  0.1712]]]]], grad_fn=<StackBackward0>)\n",
            "torch.Size([1, 2, 6, 6, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "CBatchnorm1 = CBatchnorm(in_channels=1) "
      ],
      "metadata": {
        "id": "5ZIqaRUfjhAM"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.shape)\n",
        "print(CBatchnorm1(x))\n",
        "print(CBatchnorm1(x).shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kh5Ff6bMkmwo",
        "outputId": "658c2006-6c7f-482b-8d34-f89df0e90ae7"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 1, 5, 5, 2])\n",
            "tensor([[[[[ 0.4625, -0.4345],\n",
            "           [-0.2492, -0.6675],\n",
            "           [-0.3995, -0.0650],\n",
            "           [ 0.6636,  1.9140],\n",
            "           [-0.1620, -0.1056]],\n",
            "\n",
            "          [[-1.6141, -0.9015],\n",
            "           [-0.4035,  0.9692],\n",
            "           [ 0.5049,  0.1958],\n",
            "           [ 2.5199, -0.9564],\n",
            "           [ 0.0864,  0.3517]],\n",
            "\n",
            "          [[ 0.8564, -0.1743],\n",
            "           [-1.1273,  1.5183],\n",
            "           [ 1.2328,  2.4845],\n",
            "           [-0.2767, -1.3543],\n",
            "           [-1.7000, -0.6963]],\n",
            "\n",
            "          [[-1.3393, -1.9326],\n",
            "           [ 0.5609, -0.7481],\n",
            "           [-0.2811, -0.8967],\n",
            "           [ 0.2470, -0.1657],\n",
            "           [-0.1225,  0.6096]],\n",
            "\n",
            "          [[-0.4179, -0.0791],\n",
            "           [ 0.3312, -0.5425],\n",
            "           [-0.8905,  0.2389],\n",
            "           [ 2.1253,  0.4539],\n",
            "           [-0.6071,  0.9843]]]]], grad_fn=<StackBackward0>)\n",
            "torch.Size([1, 1, 5, 5, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "CconvBlock1 = CconvBlock(in_channels = 1, out_channels = 2, kernel_size = (2,2), stride = (1,1), padding = (0,0))"
      ],
      "metadata": {
        "id": "cSlf4bl6kp8W"
      },
      "execution_count": 38,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.shape)\n",
        "print(CconvBlock1(x))\n",
        "print(CconvBlock1(x).shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yse1rlPTlOq1",
        "outputId": "1f99c5a1-ecf8-4eea-9eaf-422e5e4fc8c0"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 1, 5, 5, 2])\n",
            "1\n",
            "2\n",
            "3\n",
            "tensor([[[[[-3.6366e-03,  1.0668e-01],\n",
            "           [-2.5801e-03, -7.2432e-04],\n",
            "           [ 6.9928e-01,  3.2533e-01],\n",
            "           [ 7.5711e-01, -2.8911e-03]],\n",
            "\n",
            "          [[-1.4797e-02,  1.4519e+00],\n",
            "           [ 1.5331e+00,  1.5626e+00],\n",
            "           [ 1.8055e+00, -1.5193e-02],\n",
            "           [-2.8347e-03, -1.4290e-02]],\n",
            "\n",
            "          [[-7.2677e-03,  4.3105e-01],\n",
            "           [ 4.1220e-01,  2.2348e+00],\n",
            "           [ 1.2165e+00, -3.1249e-03],\n",
            "           [-1.6484e-02, -6.0245e-03]],\n",
            "\n",
            "          [[-1.1996e-02, -5.0755e-03],\n",
            "           [-6.7233e-03, -9.4710e-03],\n",
            "           [ 2.6352e-01, -2.6660e-03],\n",
            "           [-5.5278e-04, -1.6631e-03]]],\n",
            "\n",
            "\n",
            "         [[[ 1.6595e+00,  3.7760e-02],\n",
            "           [-9.9751e-05, -1.1516e-02],\n",
            "           [-9.8102e-03, -6.9797e-03],\n",
            "           [-8.7162e-03,  1.2551e+00]],\n",
            "\n",
            "          [[-1.1766e-02,  6.6014e-01],\n",
            "           [ 1.7939e+00, -4.7465e-03],\n",
            "           [-5.6363e-04, -3.5260e-03],\n",
            "           [ 7.3796e-01,  1.1304e+00]],\n",
            "\n",
            "          [[-6.4119e-04,  2.9422e-01],\n",
            "           [-1.7693e-02,  2.1182e+00],\n",
            "           [ 9.7289e-01,  5.9276e-01],\n",
            "           [-4.5518e-03, -1.1723e-02]],\n",
            "\n",
            "          [[-1.5494e-03, -1.1786e-02],\n",
            "           [ 2.7507e-01,  2.3672e-02],\n",
            "           [ 1.0450e+00, -1.6076e-02],\n",
            "           [-9.4527e-03,  5.2308e-01]]]]], grad_fn=<LeakyReluBackward0>)\n",
            "1\n",
            "2\n",
            "3\n",
            "torch.Size([1, 2, 4, 4, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "CConvTransBlock1 = CConvTransBlock(in_channels = 1, out_channels = 2, kernel_size = (2,2), stride = (1,1), padding = (0,0))"
      ],
      "metadata": {
        "id": "fx7XYzqElm1I"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(x.shape)\n",
        "print(CConvTransBlock1(x))\n",
        "print(CConvTransBlock1(x).shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NRWm8qGKmW4w",
        "outputId": "5af1cb46-dd7f-4ab6-a669-ef191d53e07c"
      },
      "execution_count": 41,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([1, 1, 5, 5, 2])\n",
            "tensor([[[[[ 4.8799e-01, -2.4996e-03],\n",
            "           [ 8.6699e-02, -8.1122e-03],\n",
            "           [-8.9990e-03, -5.3460e-03],\n",
            "           [-9.6118e-03,  1.1314e+00],\n",
            "           [ 8.0377e-01,  8.0137e-01],\n",
            "           [-1.3261e-03,  3.8154e-02]],\n",
            "\n",
            "          [[-6.0247e-03, -1.1592e-02],\n",
            "           [-2.4552e-02,  1.8082e-01],\n",
            "           [-1.1305e-03,  1.0884e+00],\n",
            "           [ 1.9745e+00,  4.3998e-01],\n",
            "           [ 2.3054e+00, -1.2850e-02],\n",
            "           [ 2.3022e-01,  4.3867e-01]],\n",
            "\n",
            "          [[ 1.0779e+00, -3.6623e-04],\n",
            "           [-1.1136e-02,  4.0976e-01],\n",
            "           [-5.4729e-03,  2.9596e+00],\n",
            "           [ 1.6568e+00,  6.1198e-01],\n",
            "           [-2.0432e-02, -2.5005e-02],\n",
            "           [-1.3835e-02,  2.2321e-01]],\n",
            "\n",
            "          [[-1.1945e-03, -1.5280e-02],\n",
            "           [-1.1892e-02, -1.4337e-02],\n",
            "           [ 4.4088e-01, -9.1974e-03],\n",
            "           [ 6.6649e-01, -6.9065e-03],\n",
            "           [-4.4885e-03,  2.0695e-01],\n",
            "           [-5.4372e-04,  1.2002e+00]],\n",
            "\n",
            "          [[ 2.8109e-01, -2.9100e-03],\n",
            "           [-8.5222e-03,  6.5112e-01],\n",
            "           [-8.6368e-03, -6.5221e-03],\n",
            "           [-3.3441e-04,  1.5692e+00],\n",
            "           [ 8.7103e-01, -2.2214e-03],\n",
            "           [ 1.3225e-01,  9.7924e-01]],\n",
            "\n",
            "          [[ 4.8226e-01, -1.9668e-03],\n",
            "           [ 4.1374e-01,  2.1240e-01],\n",
            "           [ 3.8393e-01, -2.4172e-03],\n",
            "           [ 1.2527e-01,  3.7175e-01],\n",
            "           [ 6.1226e-01, -9.7035e-03],\n",
            "           [ 7.8070e-01,  2.0897e-01]]],\n",
            "\n",
            "\n",
            "         [[[-2.5948e-03, -1.9661e-03],\n",
            "           [ 7.0767e-02,  2.4271e-01],\n",
            "           [ 6.7113e-01,  2.5053e-01],\n",
            "           [ 6.5146e-01, -1.3860e-02],\n",
            "           [ 7.0778e-01, -1.2573e-02],\n",
            "           [ 1.9168e-01, -2.0376e-03]],\n",
            "\n",
            "          [[ 9.5988e-01,  3.8702e-01],\n",
            "           [ 8.7895e-01,  1.4449e-01],\n",
            "           [-2.7136e-03, -4.4511e-03],\n",
            "           [-8.5156e-03,  4.6258e-01],\n",
            "           [-1.1595e-02,  4.0428e-01],\n",
            "           [-1.2286e-03, -3.9085e-03]],\n",
            "\n",
            "          [[-2.2430e-02,  3.9748e-01],\n",
            "           [ 1.0790e-02,  1.4321e-02],\n",
            "           [ 1.2593e+00, -1.6770e-02],\n",
            "           [ 1.2663e+00, -2.5498e-02],\n",
            "           [ 2.3451e+00,  9.9609e-01],\n",
            "           [ 8.1946e-01,  7.7823e-01]],\n",
            "\n",
            "          [[ 9.2214e-01,  8.0403e-01],\n",
            "           [ 3.3070e-01,  3.0029e+00],\n",
            "           [ 1.4389e+00,  2.2829e+00],\n",
            "           [-1.8718e-03,  1.0385e+00],\n",
            "           [-1.7671e-02, -5.8495e-05],\n",
            "           [-8.4579e-03, -4.5292e-03]],\n",
            "\n",
            "          [[-1.7567e-02, -4.1405e-04],\n",
            "           [-1.2102e-02, -7.8989e-03],\n",
            "           [-1.3397e-03, -3.0265e-03],\n",
            "           [-1.0003e-02, -1.0497e-02],\n",
            "           [ 2.9397e-02, -8.1583e-03],\n",
            "           [ 6.0019e-01, -1.8178e-03]],\n",
            "\n",
            "          [[-6.4545e-03,  1.6378e-01],\n",
            "           [-8.8353e-03, -3.8117e-03],\n",
            "           [-8.6314e-03,  4.4776e-01],\n",
            "           [ 6.6436e-01, -7.5805e-03],\n",
            "           [ 8.9151e-01,  7.9136e-01],\n",
            "           [-5.0883e-03,  2.7669e-01]]]]], grad_fn=<LeakyReluBackward0>)\n",
            "torch.Size([1, 2, 6, 6, 2])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "t0VfRFaDmmwm"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}