linlog.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cf9f6aff",
   "metadata": {},
   "source": [
    "# Linear Regression and Logistic Regression with PyTorch\n",
    "\n",
    "- 선형 회귀: 회귀 문제\n",
    "    - Uses MSE as loss function\n",
    "    - Simple Linear Regression: \n",
    "    $y = wx + b$\n",
    "    - Multivariable Linear Regression: \n",
    "    $y = w_1 x_1 + w_2 x_2 + ... + w_n x_n + b$\n",
    "- 로지스틱 회귀: 분류 문제\n",
    "    - Uses Sigmoid+BCE or Softmax+CE as loss function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b78283a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a45087b4",
   "metadata": {},
   "source": [
    "## Autograd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "eb104898",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(8.)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w = torch.tensor(2., requires_grad=True)\n",
    "\n",
    "y = w**2\n",
    "z = 2*y + 5\n",
    "\n",
    "z.backward()\n",
    "w.grad"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1197b17",
   "metadata": {},
   "source": [
    "## Linear Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9152f1e2",
   "metadata": {},
   "source": [
    "### single-variable, torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a797d544",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 W: 6.847 b: 1.084 Cost: 3702.000000\n",
      "Epoch:  100 W: 10.592 b: 1.380 Cost: 1.129899\n",
      "Epoch:  200 W: 10.623 b: 1.186 Cost: 1.090615\n",
      "Epoch:  300 W: 10.643 b: 1.058 Cost: 1.073371\n",
      "Epoch:  400 W: 10.657 b: 0.973 Cost: 1.065806\n",
      "Epoch:  500 W: 10.666 b: 0.916 Cost: 1.062474\n",
      "Epoch:  600 W: 10.672 b: 0.879 Cost: 1.061022\n",
      "Epoch:  700 W: 10.676 b: 0.854 Cost: 1.060377\n",
      "Epoch:  800 W: 10.678 b: 0.838 Cost: 1.060095\n",
      "Epoch:  900 W: 10.680 b: 0.827 Cost: 1.059976\n",
      "Epoch: 1000 W: 10.681 b: 0.820 Cost: 1.059917\n"
     ]
    }
   ],
   "source": [
    "x = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "y = [11, 22, 33, 44, 53, 66, 77, 87, 95]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "W = torch.zeros(1, requires_grad=True)\n",
    "b = torch.zeros(1, requires_grad=True)\n",
    "\n",
    "optimizer = optim.SGD([W, b], lr=0.01)\n",
    "\n",
    "epochs = 1000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = x * W + b\n",
    "    \n",
    "    # MSE loss\n",
    "    # mean of it\n",
    "    cost = torch.mean((pred - y) ** 2)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%100==0:\n",
    "        print(f'Epoch: {epoch:4d} W: {W.item():.3f} b: {b.item():.3f} Cost: {cost.item():.6f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d0008006",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11.500781 22.181868 32.862953 43.54404  54.22513  64.90621  75.5873\n",
      " 86.26839  96.94947 ]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11edb77c0>,\n",
       " <matplotlib.lines.Line2D at 0x11edb77f0>]"
      ]
     },
     "execution_count": 4,
     "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 matplotlib.pyplot as plt\n",
    "\n",
    "pred = x * W + b\n",
    "pred = pred.detach().numpy()\n",
    "print(pred)\n",
    "\n",
    "x = x.detach().numpy()\n",
    "y = y.detach().numpy()\n",
    "\n",
    "plt.plot(x, pred, 'b', x, y, 'k.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51ce8c58",
   "metadata": {},
   "source": [
    "### multi-variable, torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e7912861",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 29661.800781\n",
      "Epoch:    2 Cost: 3069.590088\n",
      "Epoch:    4 Cost: 322.482086\n",
      "Epoch:    6 Cost: 38.687496\n",
      "Epoch:    8 Cost: 9.365656\n",
      "Epoch:   10 Cost: 6.331847\n",
      "Epoch:   12 Cost: 6.013817\n",
      "Epoch:   14 Cost: 5.976325\n",
      "Epoch:   16 Cost: 5.967835\n",
      "Epoch:   18 Cost: 5.962291\n",
      "Epoch:   20 Cost: 5.957089\n"
     ]
    }
   ],
   "source": [
    "x = [[73, 80, 75], \n",
    "     [93, 88, 93], \n",
    "     [89, 91, 80], \n",
    "     [96, 98, 100], \n",
    "     [73, 66, 70]]\n",
    "y = [[152], [185], [180], [196], [142]]\n",
    "x = torch.FloatTensor(x) \n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "W = torch.zeros((3, 1), requires_grad=True)\n",
    "b = torch.zeros(1, requires_grad=True)\n",
    "\n",
    "optimizer = optim.SGD([W, b], lr=1e-5)\n",
    "\n",
    "epochs = 20\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = x.matmul(W) + b\n",
    "    \n",
    "    cost = torch.mean((pred - y) ** 2)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%2==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4593055",
   "metadata": {},
   "source": [
    "### single-variable, nn.Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b0717e01",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Parameter containing:\n",
      "tensor([[0.1018]], requires_grad=True), Parameter containing:\n",
      "tensor([0.0406], requires_grad=True)]\n"
     ]
    }
   ],
   "source": [
    "x = [[1], [2], [3], [4], [5], [6], [7], [8], [9]]\n",
    "y = [[11], [22], [33], [44], [53], [66], [77], [87], [95]]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "model = nn.Linear(1, 1) # (in_features, out_features)\n",
    "# model에는 W와 b가 저장되어 있음\n",
    "\n",
    "print(list(model.parameters()))\n",
    "# 각각 W와 b\n",
    "# 랜덤 초기화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "344f1ffd",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 3628.264648\n",
      "Epoch:  200 Cost: 1.092319\n",
      "Epoch:  400 Cost: 1.066130\n",
      "Epoch:  600 Cost: 1.061084\n",
      "Epoch:  800 Cost: 1.060109\n",
      "Epoch: 1000 Cost: 1.059920\n",
      "Epoch: 1200 Cost: 1.059882\n",
      "Epoch: 1400 Cost: 1.059876\n",
      "Epoch: 1600 Cost: 1.059874\n",
      "Epoch: 1800 Cost: 1.059878\n",
      "Epoch: 2000 Cost: 1.059879\n"
     ]
    }
   ],
   "source": [
    "# previously,\n",
    "# optimizer = optim.SGD([W, b], lr=0.01)\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.01) \n",
    "\n",
    "epochs = 2000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = model(x)\n",
    "    \n",
    "    # previously,\n",
    "    # cost = torch.mean((pred - y) ** 2)    \n",
    "    cost = F.mse_loss(pred, y)\n",
    "\n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%200==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "025759a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[54.2223]], grad_fn=<AddmmBackward0>)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test = torch.FloatTensor([[5]])\n",
    "output = model(x_test)\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "743eeb5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11f106970>,\n",
       " <matplotlib.lines.Line2D at 0x11f1069a0>]"
      ]
     },
     "execution_count": 9,
     "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": [
    "pred = model(x)\n",
    "pred = pred.detach().numpy()\n",
    "x = x.detach().numpy()\n",
    "y = y.detach().numpy()\n",
    "\n",
    "plt.plot(x, pred, 'b', x, y, 'k.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ae650e6",
   "metadata": {},
   "source": [
    "### multi-variable, nn.Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a13ba3c9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Parameter containing:\n",
      "tensor([[-0.4907, -0.3836, -0.4396]], requires_grad=True), Parameter containing:\n",
      "tensor([0.2206], requires_grad=True)]\n"
     ]
    }
   ],
   "source": [
    "x = [[73, 80, 75], \n",
    "     [93, 88, 93], \n",
    "     [89, 91, 80], \n",
    "     [96, 98, 100], \n",
    "     [73, 66, 70]]\n",
    "y = [[152], [185], [180], [196], [142]]\n",
    "x = torch.FloatTensor(x) \n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "model = nn.Linear(3, 1)\n",
    "\n",
    "print(list(model.parameters()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "85b4789d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 80441.710938\n",
      "Epoch:  200 Cost: 5.822568\n",
      "Epoch:  400 Cost: 5.376752\n",
      "Epoch:  600 Cost: 4.968310\n",
      "Epoch:  800 Cost: 4.593836\n",
      "Epoch: 1000 Cost: 4.250171\n",
      "Epoch: 1200 Cost: 3.934615\n",
      "Epoch: 1400 Cost: 3.644592\n",
      "Epoch: 1600 Cost: 3.377887\n",
      "Epoch: 1800 Cost: 3.132433\n",
      "Epoch: 2000 Cost: 2.906443\n"
     ]
    }
   ],
   "source": [
    "optimizer = optim.SGD(model.parameters(), lr=1e-5) \n",
    "\n",
    "epochs = 2000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = model(x)\n",
    "    \n",
    "    cost = F.mse_loss(pred, y)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%200==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "60a8c38f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[153.9698]], grad_fn=<AddmmBackward0>)\n"
     ]
    }
   ],
   "source": [
    "x_test = torch.FloatTensor([[73, 80, 75]]) \n",
    "output = model(x_test) \n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df8246f0",
   "metadata": {},
   "source": [
    "### single-variable, class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "6071906a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 4251.555664\n",
      "Epoch:  200 Cost: 1.138181\n",
      "Epoch:  400 Cost: 1.074971\n",
      "Epoch:  600 Cost: 1.062785\n",
      "Epoch:  800 Cost: 1.060438\n",
      "Epoch: 1000 Cost: 1.059987\n",
      "Epoch: 1200 Cost: 1.059900\n",
      "Epoch: 1400 Cost: 1.059882\n",
      "Epoch: 1600 Cost: 1.059877\n",
      "Epoch: 1800 Cost: 1.059874\n",
      "Epoch: 2000 Cost: 1.059876\n"
     ]
    }
   ],
   "source": [
    "x = [[1], [2], [3], [4], [5], [6], [7], [8], [9]]\n",
    "y = [[11], [22], [33], [44], [53], [66], [77], [87], [95]]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "# previously,\n",
    "# model = nn.Linear(1, 1)\n",
    "\n",
    "class LinearRegressionModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(1, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.linear(x)\n",
    "    \n",
    "model = LinearRegressionModel()\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.01)\n",
    "\n",
    "epochs = 2000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = model(x)\n",
    "    \n",
    "    cost = F.mse_loss(pred, y)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%200==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25efe62e",
   "metadata": {},
   "source": [
    "### multi-variable, class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "73f1e274",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 20691.876953\n",
      "Epoch:  200 Cost: 8.830656\n",
      "Epoch:  400 Cost: 8.053659\n",
      "Epoch:  600 Cost: 7.353873\n",
      "Epoch:  800 Cost: 6.722710\n",
      "Epoch: 1000 Cost: 6.152703\n",
      "Epoch: 1200 Cost: 5.637233\n",
      "Epoch: 1400 Cost: 5.170412\n",
      "Epoch: 1600 Cost: 4.747117\n",
      "Epoch: 1800 Cost: 4.362820\n",
      "Epoch: 2000 Cost: 4.013472\n"
     ]
    }
   ],
   "source": [
    "x = [[73, 80, 75], \n",
    "     [93, 88, 93], \n",
    "     [89, 91, 80], \n",
    "     [96, 98, 100], \n",
    "     [73, 66, 70]]\n",
    "y = [[152], [185], [180], [196], [142]]\n",
    "x = torch.FloatTensor(x) \n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "class LinearRegressionModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(3, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.linear(x)\n",
    "    \n",
    "model = LinearRegressionModel()\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=1e-5) \n",
    "\n",
    "epochs = 2000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = model(x)\n",
    "    \n",
    "    cost = F.mse_loss(pred, y)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%200==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b1d0891",
   "metadata": {},
   "source": [
    "### multi-variable, dataloader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d874f928",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Batch: 1 Cost: 37832.964844\n",
      "Epoch:    0 Batch: 2 Cost: 5383.711914\n",
      "Epoch:    0 Batch: 3 Cost: 4050.090332\n",
      "Epoch:    1 Batch: 1 Cost: 877.398438\n",
      "Epoch:    1 Batch: 2 Cost: 289.127350\n",
      "Epoch:    1 Batch: 3 Cost: 81.386353\n",
      "Epoch:    2 Batch: 1 Cost: 10.878538\n",
      "Epoch:    2 Batch: 2 Cost: 20.967859\n",
      "Epoch:    2 Batch: 3 Cost: 44.585209\n",
      "Epoch:    3 Batch: 1 Cost: 6.106197\n",
      "Epoch:    3 Batch: 2 Cost: 12.443077\n",
      "Epoch:    3 Batch: 3 Cost: 0.103541\n",
      "Epoch:    4 Batch: 1 Cost: 3.841705\n",
      "Epoch:    4 Batch: 2 Cost: 13.074860\n",
      "Epoch:    4 Batch: 3 Cost: 0.015257\n",
      "Epoch:    5 Batch: 1 Cost: 12.749397\n",
      "Epoch:    5 Batch: 2 Cost: 0.349156\n",
      "Epoch:    5 Batch: 3 Cost: 7.768914\n",
      "Epoch:    6 Batch: 1 Cost: 12.609869\n",
      "Epoch:    6 Batch: 2 Cost: 4.564456\n",
      "Epoch:    6 Batch: 3 Cost: 8.409787\n",
      "Epoch:    7 Batch: 1 Cost: 17.992006\n",
      "Epoch:    7 Batch: 2 Cost: 8.412210\n",
      "Epoch:    7 Batch: 3 Cost: 1.334093\n",
      "Epoch:    8 Batch: 1 Cost: 13.621430\n",
      "Epoch:    8 Batch: 2 Cost: 3.539710\n",
      "Epoch:    8 Batch: 3 Cost: 0.133820\n",
      "Epoch:    9 Batch: 1 Cost: 3.381795\n",
      "Epoch:    9 Batch: 2 Cost: 10.711442\n",
      "Epoch:    9 Batch: 3 Cost: 13.278049\n",
      "Epoch:   10 Batch: 1 Cost: 15.226593\n",
      "Epoch:   10 Batch: 2 Cost: 3.316264\n",
      "Epoch:   10 Batch: 3 Cost: 2.747816\n"
     ]
    }
   ],
   "source": [
    "from torch.utils.data import TensorDataset\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "x = [[73, 80, 75], \n",
    "     [93, 88, 93], \n",
    "     [89, 91, 80], \n",
    "     [96, 98, 100], \n",
    "     [73, 66, 70]]\n",
    "y = [[152], [185], [180], [196], [142]]\n",
    "x = torch.FloatTensor(x) \n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "dataset = TensorDataset(x, y)\n",
    "\n",
    "dataloader = DataLoader(dataset, batch_size=2, shuffle=True)\n",
    "\n",
    "class LinearRegressionModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(3, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.linear(x)\n",
    "    \n",
    "model = LinearRegressionModel()\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=1e-5) \n",
    "\n",
    "epochs = 10\n",
    "for epoch in range(epochs+1):\n",
    "    for batch_index, samples, in enumerate(dataloader):\n",
    "        x, y = samples\n",
    "        \n",
    "        pred = model(x)\n",
    "        \n",
    "        cost = F.mse_loss(pred, y)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        cost.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        print(f'Epoch: {epoch:4d} Batch: {batch_index+1} Cost: {cost.item():.6f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "967a4cb1",
   "metadata": {},
   "source": [
    "### multi-variable, custom dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f3d1ca79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Batch: 1 Cost: 36806.976562\n",
      "Epoch:    0 Batch: 2 Cost: 12693.960938\n",
      "Epoch:    0 Batch: 3 Cost: 6318.707031\n",
      "Epoch:    1 Batch: 1 Cost: 836.869263\n",
      "Epoch:    1 Batch: 2 Cost: 291.096802\n",
      "Epoch:    1 Batch: 3 Cost: 203.629105\n",
      "Epoch:    2 Batch: 1 Cost: 24.184956\n",
      "Epoch:    2 Batch: 2 Cost: 16.165405\n",
      "Epoch:    2 Batch: 3 Cost: 0.061444\n",
      "Epoch:    3 Batch: 1 Cost: 10.490104\n",
      "Epoch:    3 Batch: 2 Cost: 5.714315\n",
      "Epoch:    3 Batch: 3 Cost: 20.054779\n",
      "Epoch:    4 Batch: 1 Cost: 6.230009\n",
      "Epoch:    4 Batch: 2 Cost: 13.505291\n",
      "Epoch:    4 Batch: 3 Cost: 12.005566\n",
      "Epoch:    5 Batch: 1 Cost: 4.759525\n",
      "Epoch:    5 Batch: 2 Cost: 25.051466\n",
      "Epoch:    5 Batch: 3 Cost: 1.494329\n",
      "Epoch:    6 Batch: 1 Cost: 1.125180\n",
      "Epoch:    6 Batch: 2 Cost: 18.490128\n",
      "Epoch:    6 Batch: 3 Cost: 19.577412\n",
      "Epoch:    7 Batch: 1 Cost: 4.173748\n",
      "Epoch:    7 Batch: 2 Cost: 11.820674\n",
      "Epoch:    7 Batch: 3 Cost: 15.244369\n",
      "Epoch:    8 Batch: 1 Cost: 6.523158\n",
      "Epoch:    8 Batch: 2 Cost: 6.630757\n",
      "Epoch:    8 Batch: 3 Cost: 19.447594\n",
      "Epoch:    9 Batch: 1 Cost: 18.079784\n",
      "Epoch:    9 Batch: 2 Cost: 11.907951\n",
      "Epoch:    9 Batch: 3 Cost: 1.842511\n",
      "Epoch:   10 Batch: 1 Cost: 3.749647\n",
      "Epoch:   10 Batch: 2 Cost: 13.703598\n",
      "Epoch:   10 Batch: 3 Cost: 14.907263\n"
     ]
    }
   ],
   "source": [
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "class CustomDataset(Dataset):\n",
    "    def __init__(self):\n",
    "        self.x_data = [[73, 80, 75],\n",
    "                       [93, 88, 93],\n",
    "                       [89, 91, 90],\n",
    "                       [96, 98, 100],\n",
    "                       [73, 66, 70]]\n",
    "        self.y_data = [[152], [185], [180], [196], [142]]\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.x_data)\n",
    "    \n",
    "    def __getitem__(self, idx): # 1회 샘플\n",
    "        x = torch.FloatTensor(self.x_data[idx])\n",
    "        y = torch.FloatTensor(self.y_data[idx])\n",
    "        return x, y\n",
    "    \n",
    "dataset = CustomDataset()\n",
    "\n",
    "dataloader = DataLoader(dataset, batch_size=2, shuffle=True)\n",
    "\n",
    "class LinearRegressionModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(3, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.linear(x)\n",
    "    \n",
    "model = LinearRegressionModel()\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=1e-5) \n",
    "\n",
    "epochs = 10\n",
    "for epoch in range(epochs+1):\n",
    "    for batch_index, samples, in enumerate(dataloader):\n",
    "        x, y = samples\n",
    "        \n",
    "        pred = model(x)\n",
    "        \n",
    "        cost = F.mse_loss(pred, y)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        cost.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        print(f'Epoch: {epoch:4d} Batch: {batch_index+1} Cost: {cost.item():.6f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1dd6037",
   "metadata": {},
   "source": [
    "## Logistic Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62705736",
   "metadata": {},
   "source": [
    "### single-variable binary, torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8d9c97f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 0.693147\n",
      "Epoch:  100 Cost: 0.187938\n",
      "Epoch:  200 Cost: 0.176904\n",
      "Epoch:  300 Cost: 0.167174\n",
      "Epoch:  400 Cost: 0.158562\n",
      "Epoch:  500 Cost: 0.150915\n",
      "Epoch:  600 Cost: 0.144098\n",
      "Epoch:  700 Cost: 0.137998\n",
      "Epoch:  800 Cost: 0.132516\n",
      "Epoch:  900 Cost: 0.127568\n",
      "Epoch: 1000 Cost: 0.123085\n"
     ]
    }
   ],
   "source": [
    "x = [-50, -40, -30, -20, -10, -5, 0, 5, 10, 20, 30, 40, 50]\n",
    "y = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "W = torch.zeros(1, requires_grad=True)\n",
    "b = torch.zeros(1, requires_grad=True)\n",
    "\n",
    "optimizer = optim.SGD([W, b], lr=0.01)\n",
    "\n",
    "epochs = 1000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = 1/(1+torch.exp(-(x*W+b)))\n",
    "    \n",
    "    # mean of it\n",
    "    cost = -(y * torch.log(pred) + (1-y) * torch.log(1-pred)).mean()\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%100==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cf951e96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.78824541e-06, 2.12113300e-05, 2.51546036e-04, 2.97564943e-03,\n",
       "       3.41913551e-02, 1.08676426e-01, 2.95738816e-01, 5.91214299e-01,\n",
       "       8.32806230e-01, 9.83356714e-01, 9.98575211e-01, 9.99879718e-01,\n",
       "       9.99989867e-01], dtype=float32)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "output = 1/(1+torch.exp(-(x*W+b)))\n",
    "output = output.detach().numpy()\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "de5c984c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x11f1938e0>,\n",
       " <matplotlib.lines.Line2D at 0x11f193910>]"
      ]
     },
     "execution_count": 19,
     "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": [
    "x = x.detach().numpy()\n",
    "y = y.detach().numpy()\n",
    "plt.plot(x, output, 'b', x, y, 'k.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48207b15",
   "metadata": {},
   "source": [
    "### multi-variable binary, torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6d10a829",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0.5000],\n",
      "        [0.5000],\n",
      "        [0.5000],\n",
      "        [0.5000],\n",
      "        [0.5000],\n",
      "        [0.5000]], grad_fn=<SigmoidBackward0>)\n"
     ]
    }
   ],
   "source": [
    "x = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]]\n",
    "y = [[0], [0], [0], [1], [1], [1]]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "W = torch.zeros((2, 1), requires_grad=True)\n",
    "b = torch.zeros(1, requires_grad=True)\n",
    "\n",
    "# previously,\n",
    "# pred = 1/(1+torch.exp(-(x.matmul(W)+b)))\n",
    "pred = torch.sigmoid(x.matmul(W)+b)\n",
    "\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c4975ddd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.6931], grad_fn=<NegBackward0>)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss = -(y[0] * torch.log(pred[0]) + (1-y[0]) * torch.log(1-pred[0]))\n",
    "loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "56d9073e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.6931],\n",
       "        [0.6931],\n",
       "        [0.6931],\n",
       "        [0.6931],\n",
       "        [0.6931],\n",
       "        [0.6931]], grad_fn=<NegBackward0>)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "losses = -(y * torch.log(pred) + (1-y) * torch.log(1-pred))\n",
    "losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e8670244",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(0.6931, grad_fn=<MeanBackward0>)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cost = losses.mean()\n",
    "cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "b40a026a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 0.693147\n",
      "Epoch:  100 Cost: 0.134722\n",
      "Epoch:  200 Cost: 0.080643\n",
      "Epoch:  300 Cost: 0.057900\n",
      "Epoch:  400 Cost: 0.045300\n",
      "Epoch:  500 Cost: 0.037261\n",
      "Epoch:  600 Cost: 0.031673\n",
      "Epoch:  700 Cost: 0.027556\n",
      "Epoch:  800 Cost: 0.024394\n",
      "Epoch:  900 Cost: 0.021888\n",
      "Epoch: 1000 Cost: 0.019852\n"
     ]
    }
   ],
   "source": [
    "optimizer = optim.SGD([W, b], lr=1)\n",
    "\n",
    "epochs = 1000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = torch.sigmoid(x.matmul(W)+b)\n",
    "    \n",
    "    # mean of it\n",
    "    cost = -(y * torch.log(pred) + (1-y) * torch.log(1-pred)).mean()\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%100==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6927e54c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[2.7648e-04],\n",
      "        [3.1608e-02],\n",
      "        [3.8977e-02],\n",
      "        [9.5622e-01],\n",
      "        [9.9823e-01],\n",
      "        [9.9969e-01]], grad_fn=<SigmoidBackward0>)\n"
     ]
    }
   ],
   "source": [
    "pred = torch.sigmoid(x.matmul(W)+b)\n",
    "print(pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "cc708979",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[False],\n",
      "        [False],\n",
      "        [False],\n",
      "        [ True],\n",
      "        [ True],\n",
      "        [ True]])\n"
     ]
    }
   ],
   "source": [
    "prediction = pred>=torch.FloatTensor([0.5])\n",
    "print(prediction)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bde7fe4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[3.2530],\n",
      "        [1.5179]], requires_grad=True)\n",
      "tensor([-14.4819], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "print(W)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57692699",
   "metadata": {},
   "source": [
    "### multi-variable binary, nn.Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "f11f6a8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 1.260569 Accuracy: 0.17\n",
      "Epoch:   10 Cost: 0.427453 Accuracy: 0.83\n",
      "Epoch:   20 Cost: 0.581120 Accuracy: 0.83\n",
      "Epoch:   30 Cost: 0.466690 Accuracy: 0.83\n",
      "Epoch:   40 Cost: 0.380960 Accuracy: 0.83\n",
      "Epoch:   50 Cost: 0.300757 Accuracy: 0.83\n",
      "Epoch:   60 Cost: 0.230025 Accuracy: 0.83\n",
      "Epoch:   70 Cost: 0.179350 Accuracy: 1.00\n",
      "Epoch:   80 Cost: 0.154282 Accuracy: 1.00\n",
      "Epoch:   90 Cost: 0.142067 Accuracy: 1.00\n",
      "Epoch:  100 Cost: 0.132544 Accuracy: 1.00\n"
     ]
    }
   ],
   "source": [
    "x = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]]\n",
    "y = [[0], [0], [0], [1], [1], [1]]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "model = nn.Sequential(\n",
    "    nn.Linear(2, 1), \n",
    "    nn.Sigmoid()\n",
    ")\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=1)\n",
    "\n",
    "epochs = 100\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = model(x)\n",
    "    \n",
    "    # previously,\n",
    "    # cost = -(y * torch.log(pred) + (1-y) * torch.log(1-pred)).mean()\n",
    "    cost = F.binary_cross_entropy(pred, y)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%10==0:\n",
    "        prediction = pred>=torch.FloatTensor([0.5])\n",
    "        correct_prediction = prediction.float()==y\n",
    "        accuracy = correct_prediction.sum().item()/len(correct_prediction)\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f} Accuracy: {accuracy:2.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d3e31e23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.0234],\n",
       "        [0.1465],\n",
       "        [0.2699],\n",
       "        [0.7981],\n",
       "        [0.9499],\n",
       "        [0.9839]], grad_fn=<SigmoidBackward0>)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "5f023e8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Parameter containing:\n",
      "tensor([[1.5681, 0.4006]], requires_grad=True), Parameter containing:\n",
      "tensor([-6.1000], requires_grad=True)]\n"
     ]
    }
   ],
   "source": [
    "print(list(model.parameters()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "597b14ab",
   "metadata": {},
   "source": [
    "### multi-variable binary, class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "57f544cb",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 0.683832 Accuracy: 0.50\n",
      "Epoch:   10 Cost: 0.730498 Accuracy: 0.67\n",
      "Epoch:   20 Cost: 0.610570 Accuracy: 0.83\n",
      "Epoch:   30 Cost: 0.503967 Accuracy: 0.83\n",
      "Epoch:   40 Cost: 0.417193 Accuracy: 0.83\n",
      "Epoch:   50 Cost: 0.334765 Accuracy: 0.83\n",
      "Epoch:   60 Cost: 0.258952 Accuracy: 0.83\n",
      "Epoch:   70 Cost: 0.198110 Accuracy: 0.83\n",
      "Epoch:   80 Cost: 0.162520 Accuracy: 1.00\n",
      "Epoch:   90 Cost: 0.146767 Accuracy: 1.00\n",
      "Epoch:  100 Cost: 0.136500 Accuracy: 1.00\n"
     ]
    }
   ],
   "source": [
    "x = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]]\n",
    "y = [[0], [0], [0], [1], [1], [1]]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.FloatTensor(y)\n",
    "\n",
    "class BinaryClassifier(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(2, 1)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "    \n",
    "    def forward(self, x):\n",
    "        return self.sigmoid(self.linear(x))\n",
    "\n",
    "model = BinaryClassifier()\n",
    "    \n",
    "optimizer = optim.SGD(model.parameters(), lr=1)\n",
    "\n",
    "epochs = 100\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    pred = model(x)\n",
    "    \n",
    "    cost = F.binary_cross_entropy(pred, y)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%10==0:\n",
    "        prediction = pred>=torch.FloatTensor([0.5])\n",
    "        correct_prediction = prediction.float()==y\n",
    "        accuracy = correct_prediction.sum().item()/len(correct_prediction)\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f} Accuracy: {accuracy:2.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "536843f3",
   "metadata": {},
   "source": [
    "### multi-variable multi-class, torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "594f00c0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([2, 2, 2, 1, 1, 1, 0, 0])\n",
      "tensor([[0., 0., 1.],\n",
      "        [0., 0., 1.],\n",
      "        [0., 0., 1.],\n",
      "        [0., 1., 0.],\n",
      "        [0., 1., 0.],\n",
      "        [0., 1., 0.],\n",
      "        [1., 0., 0.],\n",
      "        [1., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "x = [[1, 2, 1, 1],\n",
    "     [2, 1, 3, 2],\n",
    "     [3, 1, 3, 4],\n",
    "     [4, 1, 5, 5],\n",
    "     [1, 7, 5, 5],\n",
    "     [1, 2, 5, 6],\n",
    "     [1, 6, 6, 6],\n",
    "     [1, 7, 7, 7]]\n",
    "y = [2, 2, 2, 1, 1, 1, 0, 0]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.LongTensor(y)\n",
    "print(y)\n",
    "\n",
    "y_one_hot = torch.zeros(8, 3)\n",
    "y_one_hot.scatter_(1, y.unsqueeze(1), 1)\n",
    "print(y_one_hot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "83e6590e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 1.098612\n",
      "Epoch:  100 Cost: 0.761050\n",
      "Epoch:  200 Cost: 0.689991\n",
      "Epoch:  300 Cost: 0.643229\n",
      "Epoch:  400 Cost: 0.604117\n",
      "Epoch:  500 Cost: 0.568255\n",
      "Epoch:  600 Cost: 0.533922\n",
      "Epoch:  700 Cost: 0.500291\n",
      "Epoch:  800 Cost: 0.466908\n",
      "Epoch:  900 Cost: 0.433507\n",
      "Epoch: 1000 Cost: 0.399962\n"
     ]
    }
   ],
   "source": [
    "W = torch.zeros((4, 3), requires_grad=True)\n",
    "b = torch.zeros(1, requires_grad=True)\n",
    "\n",
    "optimizer = optim.SGD([W, b], lr=0.1)\n",
    "\n",
    "epochs = 1000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    z = x.matmul(W)+b\n",
    "    # F.log_softmax() = torch.log(F.softmax())\n",
    "    # F.cross_entropy() = F.nll_loss(F.log_softmax())\n",
    "    # F.cross_entropy()는 softmax함수까지 포함하고 있음\n",
    "    cost = F.cross_entropy(z, y)\n",
    "    # F.cross_entropy()의 레이블은 원-핫 인코딩이 아님\n",
    "    # to_one_hot_vector 함수가 내장되어 있음\n",
    "    # one-hot vectors are memory inefficient\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%100==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "894ecaf0",
   "metadata": {},
   "source": [
    "### multi-variable multi-class, nn.Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "70ed2214",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 0.980161\n",
      "Epoch:  100 Cost: 0.634140\n",
      "Epoch:  200 Cost: 0.555757\n",
      "Epoch:  300 Cost: 0.503022\n",
      "Epoch:  400 Cost: 0.459435\n",
      "Epoch:  500 Cost: 0.420410\n",
      "Epoch:  600 Cost: 0.383777\n",
      "Epoch:  700 Cost: 0.348091\n",
      "Epoch:  800 Cost: 0.312230\n",
      "Epoch:  900 Cost: 0.275780\n",
      "Epoch: 1000 Cost: 0.244954\n"
     ]
    }
   ],
   "source": [
    "x = [[1, 2, 1, 1],\n",
    "     [2, 1, 3, 2],\n",
    "     [3, 1, 3, 4],\n",
    "     [4, 1, 5, 5],\n",
    "     [1, 7, 5, 5],\n",
    "     [1, 2, 5, 6],\n",
    "     [1, 6, 6, 6],\n",
    "     [1, 7, 7, 7]]\n",
    "y = [2, 2, 2, 1, 1, 1, 0, 0]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.LongTensor(y)\n",
    "\n",
    "model = nn.Linear(4, 3)\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.1)\n",
    "\n",
    "epochs = 1000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    z = model(x)\n",
    "    \n",
    "    cost = F.cross_entropy(z, y)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%100==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "057570cb",
   "metadata": {},
   "source": [
    "### multi-variable multi-class, class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "c9ca06a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch:    0 Cost: 2.651607\n",
      "Epoch:  100 Cost: 0.730743\n",
      "Epoch:  200 Cost: 0.637503\n",
      "Epoch:  300 Cost: 0.577953\n",
      "Epoch:  400 Cost: 0.526864\n",
      "Epoch:  500 Cost: 0.479029\n",
      "Epoch:  600 Cost: 0.432612\n",
      "Epoch:  700 Cost: 0.386771\n",
      "Epoch:  800 Cost: 0.341137\n",
      "Epoch:  900 Cost: 0.296026\n",
      "Epoch: 1000 Cost: 0.255381\n"
     ]
    }
   ],
   "source": [
    "x = [[1, 2, 1, 1],\n",
    "     [2, 1, 3, 2],\n",
    "     [3, 1, 3, 4],\n",
    "     [4, 1, 5, 5],\n",
    "     [1, 7, 5, 5],\n",
    "     [1, 2, 5, 6],\n",
    "     [1, 6, 6, 6],\n",
    "     [1, 7, 7, 7]]\n",
    "y = [2, 2, 2, 1, 1, 1, 0, 0]\n",
    "x = torch.FloatTensor(x)\n",
    "y = torch.LongTensor(y)\n",
    "\n",
    "class SoftmaxClassifierModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.linear = nn.Linear(4, 3)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.linear(x)\n",
    "    \n",
    "model = SoftmaxClassifierModel()\n",
    "\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.1)\n",
    "\n",
    "epochs = 1000\n",
    "for epoch in range(epochs+1):\n",
    "    \n",
    "    z = model(x)\n",
    "    \n",
    "    cost = F.cross_entropy(z, y)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    cost.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    if epoch%100==0:\n",
    "        print(f'Epoch: {epoch:4d} Cost: {cost.item():.6f}')  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19b6f046",
   "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.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}