test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import math\n",
    "\n",
    "from torch.nn import Conv2d, BatchNorm2d, MaxPool2d, Linear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from my import Conv2d as myConv2d\n",
    "from my import BatchNorm2d as myBatchNorm2d\n",
    "from my import MaxPool2d as myMaxPool2d\n",
    "from my import Linear as myLinear"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conv2d Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = torch.rand((10,3,64,64)) \n",
    "in_channels = 3\n",
    "out_channels = 7\n",
    "kernel_size = 9\n",
    "stride = (1,2)\n",
    "padding = (1,2)\n",
    "bias = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv2d = Conv2d(in_channels, out_channels, kernel_size, stride, padding, bias=bias)\n",
    "correct = conv2d(t1)\n",
    "my_conv2d = myConv2d(in_channels, out_channels, kernel_size, stride, padding, bias)\n",
    "my_conv2d.w = conv2d.weight\n",
    "my_conv2d.b = conv2d.bias\n",
    "my_ans = my_conv2d(t1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.allclose(my_ans, correct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(3.8743e-07, grad_fn=<MaxBackward1>)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(correct - my_ans).abs().max()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MaxPool2d Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "t2 = torch.rand((10,3,64,64))\n",
    "kernel_size = 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxpol2d = MaxPool2d(kernel_size)\n",
    "my_maxpol2d = myMaxPool2d(kernel_size)\n",
    "correct = maxpol2d(t2)\n",
    "my_ans = my_maxpol2d(t2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.allclose(my_ans, correct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(correct - my_ans).abs().max()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Linear Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "t3 = torch.rand((10,3))\n",
    "in_channels = 3\n",
    "out_channels = 5\n",
    "bias = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "linear = Linear(in_features=in_channels, out_features=out_channels, bias=bias)\n",
    "my_linear = myLinear(in_channels, out_channels, bias)\n",
    "my_linear.w = linear.weight\n",
    "my_linear.b = linear.bias\n",
    "correct = linear(t3)\n",
    "my_ans = my_linear(t3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.allclose(my_ans, correct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0., grad_fn=<MaxBackward1>)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(correct - my_ans).abs().max()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BatchNorm2d Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "t4 = torch.rand((10,3,64,64))\n",
    "channels = 3\n",
    "eps = 1e-5\n",
    "momentum = 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "bn2d = BatchNorm2d(channels, eps, momentum)\n",
    "my_bn2d = myBatchNorm2d(channels, eps, momentum)\n",
    "my_bn2d.running_mean = bn2d.running_mean\n",
    "my_bn2d.running_var = bn2d.running_var\n",
    "my_bn2d.gamma = bn2d.weight\n",
    "my_bn2d.beta = bn2d.bias\n",
    "correct = bn2d(t4)\n",
    "my_ans = my_bn2d(t4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.allclose(my_ans, correct)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(2.1458e-05, grad_fn=<MaxBackward1>)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(correct - my_ans).abs().max()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pytorch",
   "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.9.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "9bf3454d8134cf31c53930b86a97c38f4c38d2a7205730a8063b2bb452273ba7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}