Practise1.2 Operation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1, 2, 3, 4, 5, 6])\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import torch.nn.functional as F\n",
    "\n",
    "#1.2 Use basic operations from PyTorch Docs (https://pytorch.org/docs/stable/torch.html)\n",
    "\n",
    "#1.2.1 concatenate two tensors and save the result to a local file\n",
    "x1 = torch.tensor([1,2,3])\n",
    "x2 = torch.tensor([4,5,6])\n",
    "x = torch.cat((x1,x2))\n",
    "print(x)\n",
    "torch.save(x,'x.pt')\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "#torch.randn(2, 3)\n",
    "\n",
    "#torch.save(model, 'model.pt')\n",
    "\n",
    "#torch.set_num_threads(2)\n",
    "\n",
    "#with torch.no_grad():\n",
    "    \n",
    "#torch.sqrt(x)\n",
    "\n",
    "#F.conv2d(x, w)\n",
    "\n",
    "#F.max_pool1d(x, kernel_size=3, stride=2)\n",
    "\n",
    "#F.relu(x)\n",
    "\n",
    "#F.batch_norm(x, running_mean, running_var)\n",
    "\n",
    "#F.linear(x, w)\n",
    "\n",
    "#F.dropout(x)\n",
    "\n",
    "#F.one_hot(torch.arange(0,5))\n",
    "\n",
    "#F.cosine_similarity(x1, x2)\n",
    "\n",
    "#F.cross_entropy(x, y)\n",
    "#F.upsample(x,size=[16,16])\n",
    "\n",
    "#torch.nn.parallel.data_parallel(module, x)\n",
    "\n",
    "#nn.init.kaiming_uniform_(w, mode='fan_in', nonlinearity='relu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1, 2, 3, 4, 5, 6])\n",
      "tensor([1., 2., 3., 4., 5., 6.])\n",
      "tensor([1.0000, 1.4142, 1.7321, 2.0000, 2.2361, 2.4495])\n"
     ]
    }
   ],
   "source": [
    "#1.2.2 read tensor data from a local file, convert it to float dtype and then calculate its square root\n",
    "x = torch.load('x.pt')\n",
    "print(x)\n",
    "x = x.float()\n",
    "print(x)\n",
    "x = torch.sqrt(x)\n",
    "print(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input: tensor([[1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.],\n",
      "        [1., 1., 1., 1., 1.]])\n",
      "filter: tensor([[1., 0., 0.],\n",
      "        [0., 1., 0.],\n",
      "        [0., 0., 1.]])\n",
      "torch.Size([5, 5]) torch.Size([3, 3])\n",
      "torch.Size([1, 1, 5, 5]) torch.Size([1, 1, 3, 3])\n",
      "tensor([[[[3., 3., 3.],\n",
      "          [3., 3., 3.],\n",
      "          [3., 3., 3.]]]])\n",
      "tensor([[[[3., 3., 3., 3., 3.],\n",
      "          [3., 3., 3., 3., 3.],\n",
      "          [3., 3., 3., 3., 3.],\n",
      "          [3., 3., 3., 3., 3.],\n",
      "          [3., 3., 3., 3., 3.]]]])\n"
     ]
    }
   ],
   "source": [
    "#1.2.3 Apply a 2D convolution over an input and upsample the result\n",
    "x = torch.ones(5,5)\n",
    "w = torch.eye(3,3)\n",
    "print('input:',x)\n",
    "print('filter:',w)\n",
    "\n",
    "print(x.shape,w.shape)\n",
    "\n",
    "x = x.view(1,1,5,5)\n",
    "w = w.view(1,1,3,3)\n",
    "print(x.shape,w.shape)\n",
    "\n",
    "conv = F.conv2d(x,w)\n",
    "print(conv)\n",
    "\n",
    "up_conv = F.interpolate(conv,size=[5,5])\n",
    "print(up_conv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]]) torch.Size([1, 10])\n",
      "tensor([[2.6584e-01, 1.3295e-01, 8.7302e-01, 6.5517e-04, 6.8876e-02, 9.1124e-01,\n",
      "         3.6529e-01, 3.9072e-01, 4.1773e-01, 1.9793e-01],\n",
      "        [5.4180e-01, 8.0033e-01, 2.0021e-01, 1.4854e-01, 9.0201e-01, 4.7689e-01,\n",
      "         6.0182e-01, 6.6357e-01, 9.6789e-01, 4.6710e-01]]) torch.Size([2, 10])\n",
      "tensor([[3.6242, 5.7702]])\n",
      "tensor([[-0.0263, -0.0031]])\n"
     ]
    }
   ],
   "source": [
    "#1.2.4 Apply a linear transformation to the input and then apply a logsigmoid activation to the result\n",
    "\n",
    "x = torch.ones(1,10)\n",
    "w = torch.rand(2,10)\n",
    "print(x,x.shape)\n",
    "print(w,w.shape)\n",
    "y = F.linear(x,w,bias=None)\n",
    "print(y)\n",
    "y = F.logsigmoid(y)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: tensor([[ 1.5814, -0.5423, -0.8403, -0.6419],\n",
      "        [ 0.4298,  1.0529, -1.3988, -0.3651]])\n",
      "y: tensor([3, 0])\n",
      "loss: tensor(1.8722)\n"
     ]
    }
   ],
   "source": [
    "#1.2.5 Compute the cross-entropy loss\n",
    "\n",
    "# two samples with label from one of the 4 classes (0,1,2,3)\n",
    "x = torch.randn(2,4)\n",
    "y = torch.randint(4,(2,))\n",
    "print('x:',x)\n",
    "print('y:',y)\n",
    "loss = F.cross_entropy(x,y)\n",
    "print('loss:',loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "input : torch.Size([2, 3, 5, 5])\n",
      "filter: torch.Size([3, 3, 3, 3])\n",
      "conv_out: torch.Size([2, 3, 3, 3])\n",
      "conv_out: torch.Size([3, 18])\n",
      "linear_w: torch.Size([5, 18])\n",
      "linear_out: torch.Size([3, 5])\n"
     ]
    }
   ],
   "source": [
    "#1.2.6 Apply a 2D convolution over an input followed by a linear transformation\n",
    "\n",
    "# create a random input tensor with shape [2,3,5,5]\n",
    "\n",
    "# create a random filter with shape [4,3,3,3]\n",
    "\n",
    "# perform 2d convolution\n",
    "\n",
    "# create a random weight matrix so that the output shape is [3,5]\n",
    "\n",
    "# perform linear transformation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:pytorch_env] *",
   "language": "python",
   "name": "conda-env-pytorch_env-py"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}