Basic_project_1_regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Model define pipeline\n",
    "- Step 1: create a neural network class extends the `nn.Module` base class\n",
    "- Step 2: define the **network’s layers** in the constructor `__init__`\n",
    "- Step 3: use the network’s **layer attributes** as well as **operations** from the `nn.functional` to define the network’s **forward** pass\n",
    "\n",
    "# Properties\n",
    "- All layers (such as `nn.linear`) in PyTorch extend the `nn.Module` \n",
    "- In class constructor, `super(ModelName, self).__init__()`\n",
    "- `modelName = ModelName(); print(modelName)` lists model layers\n",
    "- `print(list(modelName.parameters()))` lists all learnable parameters\n",
    "- `modelName.named_parameters()` gives `name` and `param` \n",
    "\n",
    "\n",
    "# Training\n",
    "- `optimizer.zero_grad()`: zeroes the gradient buffers of all parameters\n",
    "- `loss.backward()`: backpropagate the errors\n",
    "- `optimizer.step()`: update the parameters\n",
    "\n",
    "from http://deeplizard.com/learn/video/k4jY9L8H89U"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x size:torch.Size([100, 1]), y size:torch.Size([100, 1])\n",
      "x type: <class 'torch.Tensor'>\n"
     ]
    }
   ],
   "source": [
    "# dummy training data\n",
    "n_samples = 100\n",
    "x_dummy = np.linspace(-3, 3, n_samples)\n",
    "\n",
    "# linear function\n",
    "# y_dummy = 3 * x_dummy + 5 + np.random.uniform(-5, 5, n_samples) # with random noise\n",
    "\n",
    "# cos() function\n",
    "y_dummy = np.cos(x_dummy) + np.random.uniform(-3, 3, n_samples)\n",
    "\n",
    "# 64-bit floating numpy array and will be converted to torch.DoubleTensor standardly\n",
    "# https://stackoverflow.com/questions/44717100/pytorch-convert-floattensor-into-doubletensor\n",
    "x = torch.tensor(x_dummy).float().view(n_samples, 1)\n",
    "# also ok\n",
    "# x_copy = torch.unsqueeze(torch.from_numpy(x_dummy), dim=1)\n",
    "\n",
    "y = torch.tensor(y_dummy).float().view(n_samples, 1)\n",
    "\n",
    "print('x size:{}, y size:{}'.format(x.size(), y.size()))\n",
    "print('x type:', type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RegressionNet(\n",
      "  (hidden): Linear(in_features=1, out_features=10, bias=True)\n",
      "  (output): Linear(in_features=10, out_features=1, bias=True)\n",
      ")\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x112e7cb38>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hidden.weight tensor([[ 0.0825],\n",
      "        [ 0.2011],\n",
      "        [-0.9203],\n",
      "        [ 0.2297],\n",
      "        [ 0.7366],\n",
      "        [-0.7626],\n",
      "        [ 0.2474],\n",
      "        [-0.3188],\n",
      "        [-0.5337],\n",
      "        [ 0.0883]])\n",
      "hidden.bias tensor([-0.5601, -0.5791,  0.0835,  0.9245,  0.4244, -0.9008,  0.2807, -0.5121,\n",
      "         0.7157, -0.7008])\n",
      "output.weight tensor([[ 0.1707,  0.1179, -0.6248,  0.3445, -0.5851, -0.4622, -0.1210, -0.2134,\n",
      "          0.2206, -0.0089]])\n",
      "output.bias tensor([0.5637])\n"
     ]
    }
   ],
   "source": [
    "class RegressionNet(nn.Module):\n",
    "    def __init__(self, in_features):\n",
    "        # default first clause\n",
    "        super(RegressionNet, self).__init__()\n",
    "        self.hidden = nn.Linear(in_features, 10)\n",
    "        self.output = nn.Linear(10, 1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.hidden(x))\n",
    "        x = self.output(x)\n",
    "        return x\n",
    "        \n",
    "regressionNet = RegressionNet(1)\n",
    "print(regressionNet)\n",
    "    \n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.SGD(regressionNet.parameters(), lr=0.01)\n",
    "\n",
    "for i in range(1000):\n",
    "    optimizer.zero_grad()\n",
    "    predictions = regressionNet(x)\n",
    "    loss = criterion(predictions, y)\n",
    "    #print('step: {}, loss: {}'.format(i, loss))\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "\n",
    "plt.scatter(x.numpy(), y.numpy())\n",
    "plt.plot(x.numpy(), predictions.data.numpy(), 'r', lw=2)\n",
    "plt.show()\n",
    "\n",
    "# print model name\n",
    "for name, param in regressionNet.named_parameters():\n",
    "    if param.requires_grad:\n",
    "        print(name, param.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}