Lab01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "MGVS81b_NU1Y"
   },
   "source": [
    "# Lab 1: Tensor Manipulation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pxAQCILvNU1c"
   },
   "source": [
    "First Author: Seungjae Ryan Lee (seungjaeryanlee at gmail dot com)\n",
    "Second Author: Ki Hyun Kim (nlp.with.deep.learning at gmail dot com)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZE_oIFGRNU1d"
   },
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "    NOTE: This corresponds to <a href=\"https://www.youtube.com/watch?v=ZYX0FaqUeN4&t=23s&list=PLlMkM4tgfjnLSOjrEJN31gZATbcj_MpUm&index=25\">Lab 8 of Deep Learning Zero to All Season 1 for TensorFlow</a>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zd2FYYN6NU1e"
   },
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zHv5TN3ZNU1e"
   },
   "source": [
    "Run `pip install -r requirements.txt` in terminal to install all required Python packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CMHjBet8NU1f"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BrGxzo6hNU1g"
   },
   "source": [
    "## NumPy Review"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rcu28jdeNU1h"
   },
   "source": [
    "We hope that you are familiar with `numpy` and basic linear algebra."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QKOqIcOJNU1i"
   },
   "source": [
    "### 1D Array with NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tXw1D6UANU1j",
    "outputId": "b2d8be1b-07dc-4ade-b039-780bcb644415"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 2. 3. 4. 5. 6.]\n"
     ]
    }
   ],
   "source": [
    "t = np.array([0., 1., 2., 3., 4., 5., 6.])\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yesb_2niNU1k",
    "outputId": "e6ff7140-99f5-49fd-9e12-04682a9147a4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rank  of t:  1\n",
      "Shape of t:  (7,)\n"
     ]
    }
   ],
   "source": [
    "print('Rank  of t: ', t.ndim)\n",
    "print('Shape of t: ', t.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YztJWbqANU1k",
    "outputId": "7d36d578-9b17-4e9a-9de1-e3ba5cb18557"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t[0] t[1] t[-1] =  0.0 1.0 6.0\n",
      "t[2:5] t[4:-1]  =  [2. 3. 4.] [4. 5.]\n",
      "t[:2] t[3:]     =  [0. 1.] [3. 4. 5. 6.]\n"
     ]
    }
   ],
   "source": [
    "print('t[0] t[1] t[-1] = ', t[0], t[1], t[-1]) # Element\n",
    "print('t[2:5] t[4:-1]  = ', t[2:5], t[4:-1])   # Slicing\n",
    "print('t[:2] t[3:]     = ', t[:2], t[3:])      # Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XJ04kxsyNU1l"
   },
   "source": [
    "### 2D Array with NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "luD9Xla3PFro"
   },
   "source": [
    "Q1.\n",
    "\n",
    "[[  1.   2.   3.]\n",
    " [  4.   5.   6.]\n",
    " [  7.   8.   9.]\n",
    " [ 10.  11.  12.]]\n",
    " \n",
    " np.array를 이용해 위 배열을 만드세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "id": "7GF5YttcNU1l",
    "outputId": "6f3e2fd4-bf6f-4bd0-acf8-8a84d25b895b"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [2]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m t \u001b[38;5;241m=\u001b[39m \u001b[43mnp\u001b[49m\u001b[38;5;241m.\u001b[39marray([\n\u001b[0;32m      2\u001b[0m     [\u001b[38;5;241m1.\u001b[39m, \u001b[38;5;241m2.\u001b[39m, \u001b[38;5;241m3.\u001b[39m],\n\u001b[0;32m      3\u001b[0m     [\u001b[38;5;241m4.\u001b[39m, \u001b[38;5;241m5.\u001b[39m, \u001b[38;5;241m6.\u001b[39m],\n\u001b[0;32m      4\u001b[0m     [\u001b[38;5;241m7.\u001b[39m, \u001b[38;5;241m8.\u001b[39m, \u001b[38;5;241m9.\u001b[39m],\n\u001b[0;32m      5\u001b[0m     [\u001b[38;5;241m10.\u001b[39m, \u001b[38;5;241m11.\u001b[39m, \u001b[38;5;241m12.\u001b[39m]\n\u001b[0;32m      6\u001b[0m ])\n\u001b[0;32m      8\u001b[0m \u001b[38;5;28mprint\u001b[39m(t)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "t = np.array([\n",
    "    [1., 2., 3.],\n",
    "    [4., 5., 6.],\n",
    "    [7., 8., 9.],\n",
    "    [10., 11., 12.]\n",
    "])\n",
    "\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rKcr0QIMPcrn"
   },
   "source": [
    "Q2.\n",
    "\n",
    "Rank  of t:  2\n",
    "\n",
    "Shape of t:  (4, 3)\n",
    "\n",
    "위에 처럼 print 되도록 ndim과 shape을 이용해 코드를 완성시키세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "id": "3wjfyJHdNU1m",
    "outputId": "3d24b97e-512d-4bd7-fd0e-da2abac39490"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 't' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [1]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mRank  of t: \u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[43mt\u001b[49m\u001b[38;5;241m.\u001b[39mndim)\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mShape of t: \u001b[39m\u001b[38;5;124m'\u001b[39m, t\u001b[38;5;241m.\u001b[39mshape)\n",
      "\u001b[1;31mNameError\u001b[0m: name 't' is not defined"
     ]
    }
   ],
   "source": [
    "print('Rank  of t: ', t.ndim)\n",
    "print('Shape of t: ', t.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o3zZaDFeNU1m"
   },
   "source": [
    "## PyTorch is like NumPy (but better)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x40SVjvQNU1n"
   },
   "source": [
    "### 1D Array with PyTorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RsNWpdyfNU1n",
    "outputId": "cf718828-5c20-4edb-d764-38f9bfc62fcd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0., 1., 2., 3., 4., 5., 6.])\n"
     ]
    }
   ],
   "source": [
    "t = torch.FloatTensor([0., 1., 2., 3., 4., 5., 6.])\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "krSaK2eINU1n",
    "outputId": "a5b9bdcc-3b23-414a-de27-c19db4fdffa1",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "torch.Size([7])\n",
      "torch.Size([7])\n",
      "tensor(0.) tensor(1.) tensor(6.)\n",
      "tensor([2., 3., 4.]) tensor([4., 5.])\n",
      "tensor([0., 1.]) tensor([3., 4., 5., 6.])\n"
     ]
    }
   ],
   "source": [
    "print(t.dim())  # rank\n",
    "print(t.shape)  # shape\n",
    "print(t.size()) # shape\n",
    "print(t[0], t[1], t[-1])  # Element\n",
    "print(t[2:5], t[4:-1])    # Slicing\n",
    "print(t[:2], t[3:])       # Slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "miBtWfC3NU1o"
   },
   "source": [
    "### 2D Array with PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qzrpW_0WQ3US"
   },
   "source": [
    "Q3.\n",
    "\n",
    "[[ 1.,  2.,  3.],\n",
    "\n",
    " [ 4.,  5.,  6.],\n",
    "\n",
    " [ 7.,  8.,  9.],\n",
    "\n",
    " [10., 11., 12.]]\n",
    "\n",
    "위에 처럼 print 되도록 코드를 완성시키세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7gPzVUk9NU1o",
    "outputId": "2a1c0e60-ecee-4ed4-8578-d88b0f0cff53"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 1.,  2.,  3.],\n",
      "        [ 4.,  5.,  6.],\n",
      "        [ 7.,  8.,  9.],\n",
      "        [10., 11., 12.]])\n"
     ]
    }
   ],
   "source": [
    "t = torch.FloatTensor([\n",
    "    [1., 2., 3.],\n",
    "    [4., 5., 6.],\n",
    "    [7., 8., 9.],\n",
    "    [10., 11., 12.]\n",
    "])\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L6sZZSUiRFfA"
   },
   "source": [
    "Q4.\n",
    "\n",
    "2\n",
    "\n",
    "torch.Size([4, 3])\n",
    "\n",
    "tensor([ 2.,  5.,  8., 11.])\n",
    "\n",
    "torch.Size([4])\n",
    "\n",
    "tensor([[ 1.,  2.],\n",
    "        [ 4.,  5.],\n",
    "        [ 7.,  8.],\n",
    "        [10., 11.]])\n",
    "\n",
    "위에 처럼 print 되도록 dim, size, slicing을 이용해 코드를 완성시키세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "o32_vbu0NU1p",
    "outputId": "24839111-7ea8-473f-b4d2-7aac4c922e39"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "torch.Size([4, 3])\n",
      "tensor([ 2.,  5.,  8., 11.])\n",
      "torch.Size([4])\n",
      "tensor([[ 1.,  2.],\n",
      "        [ 4.,  5.],\n",
      "        [ 7.,  8.],\n",
      "        [10., 11.]])\n"
     ]
    }
   ],
   "source": [
    "print(t.dim())  # rank\n",
    "print(t.size()) # shape\n",
    "print(t[:,2])\n",
    "print(t[:,1].size())\n",
    "print(t[:,:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z6XUW0zNNU1p"
   },
   "source": [
    "### Shape, Rank, Axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "m0dqzUU1NU1p",
    "outputId": "c20629d1-f3ff-4565-f181-e7960ddbf389"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[[ 1.,  2.,  3.,  4.],\n",
      "          [ 5.,  6.,  7.,  8.],\n",
      "          [ 9., 10., 11., 12.]],\n",
      "\n",
      "         [[13., 14., 15., 16.],\n",
      "          [17., 18., 19., 20.],\n",
      "          [21., 22., 23., 24.]]]])\n"
     ]
    }
   ],
   "source": [
    "t = torch.FloatTensor([[[[1, 2, 3, 4],\n",
    "                         [5, 6, 7, 8],\n",
    "                         [9, 10, 11, 12]],\n",
    "                       [[13, 14, 15, 16],\n",
    "                        [17, 18, 19, 20],\n",
    "                        [21, 22, 23, 24]]\n",
    "                       ]])\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bSg1NRdMNU1q",
    "outputId": "d5532e7e-6d74-4a86-fba8-f7bb4ee00eed"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "torch.Size([1, 2, 3, 4])\n"
     ]
    }
   ],
   "source": [
    "print(t.dim())  # rank  = 4\n",
    "print(t.size()) # shape = (1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CkPXuFEENU1q"
   },
   "source": [
    "## Frequently Used Operations in PyTorch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "valB43wrNU1q"
   },
   "source": [
    "### Mul vs. Matmul"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "o1Qh5tYvNU1r",
    "outputId": "7f2654f5-ead1-41fe-9559-6307e1ffbd67"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "-------------\n",
      "Mul vs Matmul\n",
      "-------------\n",
      "Shape of Matrix 1:  torch.Size([2, 2])\n",
      "Shape of Matrix 2:  torch.Size([2, 1])\n",
      "tensor([[ 5.],\n",
      "        [11.]])\n",
      "Shape of Matrix 1:  torch.Size([2, 2])\n",
      "Shape of Matrix 2:  torch.Size([2, 1])\n",
      "tensor([[1., 2.],\n",
      "        [6., 8.]])\n",
      "tensor([[1., 2.],\n",
      "        [6., 8.]])\n"
     ]
    }
   ],
   "source": [
    "print()\n",
    "print('-------------')\n",
    "print('Mul vs Matmul')\n",
    "print('-------------')\n",
    "m1 = torch.FloatTensor([[1, 2], [3, 4]])\n",
    "m2 = torch.FloatTensor([[1], [2]])\n",
    "print('Shape of Matrix 1: ', m1.shape) # 2 x 2\n",
    "print('Shape of Matrix 2: ', m2.shape) # 2 x 1\n",
    "print(m1.matmul(m2)) # 2 x 1\n",
    "\n",
    "m1 = torch.FloatTensor([[1, 2], [3, 4]])\n",
    "m2 = torch.FloatTensor([[1], [2]])\n",
    "print('Shape of Matrix 1: ', m1.shape) # 2 x 2\n",
    "print('Shape of Matrix 2: ', m2.shape) # 2 x 1\n",
    "print(m1 * m2) # 2 x 2\n",
    "print(m1.mul(m2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p00N4ZoL_YXW"
   },
   "source": [
    "Q5. 해당 함수가 행렬 곱셈인지 element-wise 곱셈인지 적어주세요. \n",
    "\n",
    ".matmul : 행렬곱셈\n",
    "\n",
    ".mul : element-wise 곱셈"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xZrWTpo8NU1r"
   },
   "source": [
    "### Broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LgeYT1_UNU1r"
   },
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "    Carelessly using broadcasting can lead to code hard to debug.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3z1209BfNU1r",
    "outputId": "28facd97-ba94-4bb9-bb4b-c973eeac82b4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[5., 5.]])\n"
     ]
    }
   ],
   "source": [
    "# Same shape\n",
    "m1 = torch.FloatTensor([[3, 3]])\n",
    "m2 = torch.FloatTensor([[2, 2]])\n",
    "print(m1 + m2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hwzCVLVsNU1s",
    "outputId": "72d56d81-5e84-4004-d3d1-a389f253baf1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[4., 5.]])\n"
     ]
    }
   ],
   "source": [
    "# Vector + scalar\n",
    "m1 = torch.FloatTensor([[1, 2]])\n",
    "m2 = torch.FloatTensor([3]) # 3 -> [[3, 3]]\n",
    "print(m1 + m2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mq80DSaiNU1s",
    "outputId": "98cce908-a168-48c0-b98c-ed0277faf06b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[4., 5.],\n",
      "        [5., 6.]])\n"
     ]
    }
   ],
   "source": [
    "# 2 x 1 Vector + 1 x 2 Vector\n",
    "m1 = torch.FloatTensor([[1, 2]])\n",
    "m2 = torch.FloatTensor([[3], [4]])\n",
    "print(m1 + m2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mHZ_HzNxT33B"
   },
   "source": [
    "Q6. 브로드캐스팅 과정에서 실제로 두 텐서가 어떻게 변경되는지 서술해주세요.\n",
    "\n",
    "[1, 2]\n",
    "\n",
    "==> \n",
    "\n",
    "[3]\n",
    "[4]\n",
    "\n",
    "==> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tNTZ1ekmNU1s"
   },
   "source": [
    "### Mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HC65S9hfNU1s",
    "outputId": "eebcbfe6-1558-414d-87af-f38ad7a15c04"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(1.5000)\n"
     ]
    }
   ],
   "source": [
    "t = torch.FloatTensor([1, 2])\n",
    "print(t.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "maNH7M71NU1t",
    "outputId": "dacb2957-6323-4826-9a33-dd6614d3d69a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can only calculate the mean of floating types. Got Long instead.\n"
     ]
    }
   ],
   "source": [
    "# Can't use mean() on integers\n",
    "t = torch.LongTensor([1, 2])\n",
    "try:\n",
    "    print(t.mean())\n",
    "except Exception as exc:\n",
    "    print(exc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "owBY3zGENU1t"
   },
   "source": [
    "You can also use `t.mean` for higher rank tensors to get mean of all elements, or mean by particular dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "asuNyDIPNU1t",
    "outputId": "8c7f57f3-8550-45de-d2bf-ad5ab7352684"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 2.],\n",
      "        [3., 4.]])\n"
     ]
    }
   ],
   "source": [
    "t = torch.FloatTensor([[1, 2], [3, 4]])\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "55pHjHfmNU1t",
    "outputId": "1fce7282-b8c1-43c4-9faf-4a5091c539d9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(2.5000)\n",
      "tensor([2., 3.])\n",
      "tensor([1.5000, 3.5000])\n",
      "tensor([1.5000, 3.5000])\n"
     ]
    }
   ],
   "source": [
    "print(t.mean())\n",
    "print(t.mean(dim=0))\n",
    "print(t.mean(dim=1))\n",
    "print(t.mean(dim=-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1eOcNbv2A1sT"
   },
   "source": [
    "Q7.\n",
    "\n",
    "t = torch.FloatTensor([[4, 6], [3, 2], [2, 4]])\n",
    "\n",
    "위 텐서를 이용해 \n",
    "\n",
    "t.mean()        => tensor(3.5000)\n",
    "\n",
    "t.mean(dim=0)   => tensor([3., 4.])\n",
    "\n",
    "t.mean(dim=1)   => tensor([5.0000, 2.5000, 3.0000])\n",
    "\n",
    "t.mean(dim=-1)  => tensor([5.0000, 2.5000, 3.0000])\n",
    "\n",
    "를 수행하면 어떤 결과가 나오는지 코드를 작성해보세요.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OwygKn7qC9_v"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Pm3314vdNU1u"
   },
   "source": [
    "### Sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ZfCSxjomNU1u",
    "outputId": "c7e7d8fe-e698-4bd8-c807-91a55bcdc3d9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 2.],\n",
      "        [3., 4.]])\n"
     ]
    }
   ],
   "source": [
    "t = torch.FloatTensor([[1, 2], [3, 4]])\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YXGOsiqKNU1u",
    "outputId": "711282ff-a75d-4490-d89f-2845bb006644"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(10.)\n",
      "tensor([4., 6.])\n",
      "tensor([3., 7.])\n",
      "tensor([3., 7.])\n"
     ]
    }
   ],
   "source": [
    "print(t.sum())\n",
    "print(t.sum(dim=0))\n",
    "print(t.sum(dim=1))\n",
    "print(t.sum(dim=-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f3HuHKF_CaWw"
   },
   "source": [
    "Q8.\n",
    "\n",
    "t = torch.FloatTensor([[4, 6], [3, 2], [2, 4]])\n",
    "\n",
    "위 텐서를 이용해 \n",
    "\n",
    "t.sum()        => tensor(21.)\n",
    "\n",
    "t.sum(dim=0)   => tensor([9., 12.])\n",
    "\n",
    "t.sum(dim=1)   => tensor([10., 5., 6.])\n",
    "\n",
    "t.sum(dim=-1)  => tensor([10., 5., 6.])\n",
    "\n",
    "를 수행하면 어떤 결과가 나오는지 코드를 작성해보세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qeqPDGQ6C89S"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZZGSL9SZNU1u"
   },
   "source": [
    "### Max and Argmax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QBSUyjuwNU1u",
    "outputId": "e767dc0e-dc08-48f2-eefb-c288cd0fae9b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 2.],\n",
      "        [3., 4.]])\n"
     ]
    }
   ],
   "source": [
    "t = torch.FloatTensor([[1, 2], [3, 4]])\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8CAe4gAlNU1v"
   },
   "source": [
    "The `max` operator returns one value if it is called without an argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WPhyy2d8NU1v",
    "outputId": "f3c54d69-bb06-410a-9673-fe1ebea65e50"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(4.)\n"
     ]
    }
   ],
   "source": [
    "print(t.max()) # Returns one value: max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VYtaOt_nNU1v"
   },
   "source": [
    "The `max` operator returns 2 values when called with dimension specified. The first value is the maximum value, and the second value is the argmax: the index of the element with maximum value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8cmqoSHoNU1v",
    "outputId": "b87d3395-0a59-4ba5-f51a-2f32124053f1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([3., 4.]), tensor([1, 1]))\n",
      "Max:  tensor([3., 4.])\n",
      "Argmax:  tensor([1, 1])\n"
     ]
    }
   ],
   "source": [
    "print(t.max(dim=0)) # Returns two values: max and argmax\n",
    "print('Max: ', t.max(dim=0)[0])\n",
    "print('Argmax: ', t.max(dim=0)[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5cLC3TtdNU1v",
    "outputId": "9a948fae-7384-47ba-c78b-7df3d3701a60"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(tensor([2., 4.]), tensor([1, 1]))\n",
      "(tensor([2., 4.]), tensor([1, 1]))\n"
     ]
    }
   ],
   "source": [
    "print(t.max(dim=1))\n",
    "print(t.max(dim=-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vr_ewhnrDquC"
   },
   "source": [
    "Q9. max와 argmax의 차이는?\n",
    "\n",
    "=> max 는 원소의 최댓값을 리턴, argmax는 원소의 최댓값의 인덱스를 리턴"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_lbEKsYoNU1w"
   },
   "source": [
    "### View"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XcFtMcf7NU1w"
   },
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "    This is a function hard to master, but is very useful!\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "L0tjyi9oNU1w",
    "outputId": "0f9f5460-9c21-4ce4-eb6d-8e5fb4487d10"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 2, 3])\n"
     ]
    }
   ],
   "source": [
    "t = np.array([[[0, 1, 2],\n",
    "               [3, 4, 5]],\n",
    "\n",
    "              [[6, 7, 8],\n",
    "               [9, 10, 11]]])\n",
    "ft = torch.FloatTensor(t)\n",
    "print(ft.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1HlcdlpfNU1w",
    "outputId": "081ae6fa-5be2-4511-cc42-4d69b53b1c58"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ 0.,  1.,  2.],\n",
      "        [ 3.,  4.,  5.],\n",
      "        [ 6.,  7.,  8.],\n",
      "        [ 9., 10., 11.]])\n",
      "torch.Size([4, 3])\n"
     ]
    }
   ],
   "source": [
    "print(ft.view([-1, 3]))\n",
    "print(ft.view([-1, 3]).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "NdCajRzQNU1x",
    "outputId": "c7e0d2a0-6269-42a5-e1ac-d067bf2c27b9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[[ 0.,  1.,  2.]],\n",
      "\n",
      "        [[ 3.,  4.,  5.]],\n",
      "\n",
      "        [[ 6.,  7.,  8.]],\n",
      "\n",
      "        [[ 9., 10., 11.]]])\n",
      "torch.Size([4, 1, 3])\n"
     ]
    }
   ],
   "source": [
    "print(ft.view([-1, 1, 3]))\n",
    "print(ft.view([-1, 1, 3]).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "e_BMUa3jEfaa"
   },
   "source": [
    "Q10. 위 텐서에서 ft.view([2, -1])을 수행하면\n",
    "\n",
    "size가 어떻게 나올지 코드를 작성해보세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7mGkH1gHE8eC"
   },
   "outputs": [],
   "source": [
    "torch.Size([2, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Wjtj7QZXNU1x"
   },
   "source": [
    "### Squeeze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "OdN1HPAhNU1x",
    "outputId": "37c1ab6b-b0ec-4a09-96e9-53da337cd53c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.],\n",
      "        [1.],\n",
      "        [2.]])\n",
      "torch.Size([3, 1])\n"
     ]
    }
   ],
   "source": [
    "ft = torch.FloatTensor([[0], [1], [2]])\n",
    "print(ft)\n",
    "print(ft.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hajNFrL7NU1x",
    "outputId": "1cfbfb73-dc93-4eac-c207-96c49e043bba"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0., 1., 2.])\n",
      "torch.Size([3])\n"
     ]
    }
   ],
   "source": [
    "print(ft.squeeze())\n",
    "print(ft.squeeze().shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t9T645XlNU1y"
   },
   "source": [
    "### Unsqueeze"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "1AIW02xHNU1y",
    "outputId": "a57a83b7-3ffb-486f-a0a2-0235d40604bb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([3])\n"
     ]
    }
   ],
   "source": [
    "ft = torch.Tensor([0, 1, 2])\n",
    "print(ft.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RSXuk_5JNU1y",
    "outputId": "7447bb5c-0d73-4c85-9595-fec6cff66357"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0., 1., 2.]])\n",
      "torch.Size([1, 3])\n"
     ]
    }
   ],
   "source": [
    "print(ft.unsqueeze(0))\n",
    "print(ft.unsqueeze(0).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yvlVlE5wXJK7"
   },
   "source": [
    "Q11. 위에서 배운 view를 이용해서\n",
    "\n",
    "tensor([[0., 1., 2.]])\n",
    "\n",
    "torch.Size([1, 3])\n",
    "\n",
    "print 되도록 코드를 완성해보세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kvhOsU6TNU1y",
    "outputId": "f3cea3ca-a930-4c85-d760-9159ffaf0cb4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0., 1., 2.]])\n",
      "torch.Size([1, 3])\n"
     ]
    }
   ],
   "source": [
    "print(ft.unsqueeze(0))\n",
    "print(ft.unsqueeze(0).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "RIYWu26NNU1y",
    "outputId": "275d26bf-cfed-41fa-fa65-f959d904ccc1"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.],\n",
      "        [1.],\n",
      "        [2.]])\n",
      "torch.Size([3, 1])\n"
     ]
    }
   ],
   "source": [
    "print(ft.unsqueeze(1))\n",
    "print(ft.unsqueeze(1).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Xi0sNynYNU1y",
    "outputId": "4edc2856-6375-43d1-e1fd-66a2db0c6cf7"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.],\n",
      "        [1.],\n",
      "        [2.]])\n",
      "torch.Size([3, 1])\n"
     ]
    }
   ],
   "source": [
    "print(ft.unsqueeze(-1))\n",
    "print(ft.unsqueeze(-1).shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hEESqUixFzx0"
   },
   "source": [
    "Q12. 각각의 함수의 역할을 서술하세요.\n",
    "\n",
    "view => 차원을 바꾼다.\n",
    "\n",
    "squeeze => 차원을 없앤다.\n",
    "\n",
    "unsqueeze => 차원을 추가한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ItsjR8GaNU1z"
   },
   "source": [
    "### Scatter (for one-hot encoding)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QCQPvADLNU1z"
   },
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "    Scatter is a very flexible function. We only discuss how to use it to get a one-hot encoding of indices.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "wuyh3iSdNU1z",
    "outputId": "cacd183d-484d-4ffc-910e-b5b5ce44ee49"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0],\n",
      "        [1],\n",
      "        [2],\n",
      "        [0]])\n"
     ]
    }
   ],
   "source": [
    "lt = torch.LongTensor([[0], [1], [2], [0]])\n",
    "print(lt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "OcdGRjgzNU1z",
    "outputId": "fa895016-b3a7-4836-b06a-f2302864375a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 0., 0.],\n",
      "        [0., 1., 0.],\n",
      "        [0., 0., 1.],\n",
      "        [1., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "one_hot = torch.zeros(4, 3) # batch_size = 4, classes = 3\n",
    "one_hot.scatter_(1, lt, 1)\n",
    "print(one_hot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jJ8wSeaBNU1z"
   },
   "source": [
    "### Casting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "0ac3IZvwNU10",
    "outputId": "4c770db2-c731-42d6-d198-e13e8099f337"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1, 2, 3, 4])\n"
     ]
    }
   ],
   "source": [
    "lt = torch.LongTensor([1, 2, 3, 4])\n",
    "print(lt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "a2w9jrfuNU10",
    "outputId": "98de873c-17f9-4c71-8c7f-fa79c7165d04"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1., 2., 3., 4.])\n"
     ]
    }
   ],
   "source": [
    "print(lt.float())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Zs6AYeiXNU10",
    "outputId": "6e33d9ba-0f0a-462e-e74a-909b4bcf9c71"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1, 0, 0, 1], dtype=torch.uint8)\n"
     ]
    }
   ],
   "source": [
    "bt = torch.ByteTensor([True, False, False, True])\n",
    "print(bt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3950v-cINU10",
    "outputId": "192f27de-080d-4f01-b21e-39db729f83d0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([1, 0, 0, 1])\n",
      "tensor([1., 0., 0., 1.])\n"
     ]
    }
   ],
   "source": [
    "print(bt.long())\n",
    "print(bt.float())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "balKxmeuNU10"
   },
   "source": [
    "### Concatenation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "TX0M_IAeNU10"
   },
   "outputs": [],
   "source": [
    "x = torch.FloatTensor([[1, 2], [3, 4]])\n",
    "y = torch.FloatTensor([[5, 6], [7, 8]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "baiFG50HNU11",
    "outputId": "11525378-4a5d-401c-d08a-131d0f695253"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 2.],\n",
      "        [3., 4.],\n",
      "        [5., 6.],\n",
      "        [7., 8.]])\n",
      "tensor([[1., 2., 5., 6.],\n",
      "        [3., 4., 7., 8.]])\n"
     ]
    }
   ],
   "source": [
    "print(torch.cat([x, y], dim=0))\n",
    "print(torch.cat([x, y], dim=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JGhMkgALKCTs"
   },
   "source": [
    "Q13.\n",
    "\n",
    "x = torch.FloatTensor([[1, 2, 3], [3, 4, 5]])\n",
    "\n",
    "y = torch.FloatTensor([[5, 6, 2], [7, 8, 5]])\n",
    "\n",
    "위 텐서를 이용해 concatenation하는 코드를 작성해보세요.(dim=0, dim=1 둘다 이용)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "S5F2W5YfK85S"
   },
   "outputs": [],
   "source": [
    "torch.cat([x,y],dim=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hQSGh9kWNU11"
   },
   "source": [
    "### Stacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ogaSr4pVNU11"
   },
   "outputs": [],
   "source": [
    "x = torch.FloatTensor([1, 4])\n",
    "y = torch.FloatTensor([2, 5])\n",
    "z = torch.FloatTensor([3, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "E0k-6xg5NU11",
    "outputId": "f0f223a0-ae91-45da-e763-62869bc20128"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 4.],\n",
      "        [2., 5.],\n",
      "        [3., 6.]])\n",
      "tensor([[1., 2., 3.],\n",
      "        [4., 5., 6.]])\n"
     ]
    }
   ],
   "source": [
    "print(torch.stack([x, y, z]))\n",
    "print(torch.stack([x, y, z], dim=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LZJj4aDiLG4A"
   },
   "source": [
    "Q14. torch.cat, unsqueeze를 이용해\n",
    "tensor([[1., 4.],\n",
    "        [2., 5.],\n",
    "        [3., 6.]])를 출력해보세요. (위에 있는 x,y,z 이용)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Yp1vvNfiLqxe"
   },
   "outputs": [],
   "source": [
    "print(torch.cat([x.unsqueeze(0),y.unsqueeze(0),z.unsqueeze(0)],dim=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "91MPElpSNU11"
   },
   "source": [
    "### Ones and Zeros Like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "dqx9PxAzNU12",
    "outputId": "bd6ce8c4-7ed0-4cb1-d7b3-d02f450e07a4"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0., 1., 2.],\n",
      "        [2., 1., 0.]])\n"
     ]
    }
   ],
   "source": [
    "x = torch.FloatTensor([[0, 1, 2], [2, 1, 0]])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "4zHRitCzNU12",
    "outputId": "bb1bd9ad-cf3c-4bf3-8716-e459fd115439"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[1., 1., 1.],\n",
      "        [1., 1., 1.]])\n",
      "tensor([[0., 0., 0.],\n",
      "        [0., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "print(torch.ones_like(x))\n",
    "print(torch.zeros_like(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KIca6nqqNU12"
   },
   "source": [
    "### In-place Operation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LwoJanfUNU12"
   },
   "outputs": [],
   "source": [
    "x = torch.FloatTensor([[1, 2], [3, 4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "C9qnpo0jNU12",
    "outputId": "1d104d4a-ddba-4f5d-a356-d0123c0726cc"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[2., 4.],\n",
      "        [6., 8.]])\n",
      "tensor([[1., 2.],\n",
      "        [3., 4.]])\n",
      "tensor([[2., 4.],\n",
      "        [6., 8.]])\n",
      "tensor([[2., 4.],\n",
      "        [6., 8.]])\n"
     ]
    }
   ],
   "source": [
    "print(x.mul(2.))\n",
    "print(x)\n",
    "print(x.mul_(2.))\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Fn1TgMv1L4hc"
   },
   "source": [
    "Q15. 연산 뒤에 '_'가 있고 없고의 차이는?\n",
    "\n",
    "=> 연산 뒤에 언더바가 있으면 연산한 값을 반환함에 동시에 연산된 값을 원래 값에    저장함"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "URsM3XHWNU13"
   },
   "source": [
    "## Miscellaneous"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1LchUaMmNU13"
   },
   "source": [
    "### Zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "r_sQlkJwNU13",
    "outputId": "e13d8fed-dcbe-4746-8aa7-80112d266e42"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4\n",
      "2 5\n",
      "3 6\n"
     ]
    }
   ],
   "source": [
    "for x, y in zip([1, 2, 3], [4, 5, 6]):\n",
    "    print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hNRO4TI3NU13",
    "outputId": "0f562122-ad07-443f-a929-0a8c7b7ade32"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4 7\n",
      "2 5 8\n",
      "3 6 9\n"
     ]
    }
   ],
   "source": [
    "for x, y, z in zip([1, 2, 3], [4, 5, 6], [7, 8, 9]):\n",
    "    print(x, y, z)"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Lab01.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}