20191104_basic_neural_network.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "20191104_basic_neural_network.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/luou-wen/NLP-learning/blob/main/20191104_basic_neural_network.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bs_JfNL0B_8E"
      },
      "source": [
        "Basic neural network"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pya0Mw6NPMjI",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        },
        "outputId": "fd4d78ea-6a35-4d18-ef40-c5ef80153e34"
      },
      "source": [
        "# !pip3 install torch torchvision"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: torch in /usr/local/lib/python3.6/dist-packages (1.3.0+cu100)\n",
            "Requirement already satisfied: torchvision in /usr/local/lib/python3.6/dist-packages (0.4.1+cu100)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from torch) (1.17.3)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from torchvision) (1.12.0)\n",
            "Requirement already satisfied: pillow>=4.1.1 in /usr/local/lib/python3.6/dist-packages (from torchvision) (4.3.0)\n",
            "Requirement already satisfied: olefile in /usr/local/lib/python3.6/dist-packages (from pillow>=4.1.1->torchvision) (0.46)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9UoT75plPoqK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        },
        "outputId": "be292f8a-5f8b-48f0-d630-807ab377078b"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "X = torch.tensor(([2,9], [1,5], [3,6]), dtype=torch.float) #3 x 2 tensor\n",
        "y = torch.tensor(([92], [100], [89]), dtype=torch.float) # 3 x 1 tensor\n",
        "xPredicted = torch.tensor(([4, 8]), dtype=torch.float) # 1x 2 tensor\n",
        "\n",
        "print(X.size())\n",
        "print(y.size())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "torch.Size([3, 2])\n",
            "torch.Size([3, 1])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bbQ1y97sTzp_"
      },
      "source": [
        "# Scaling:\n",
        "\n",
        "# max function returns both a tensor and the corresponding indices.\n",
        "# so we use _ to capture the indices which we won't use, only interested in the max value\n",
        "X_max, _ = torch.max(X,0)\n",
        "xPredicted_max, _ = torch.max(xPredicted, 0) # finds the max value in a tensor\n",
        "\n",
        "X = torch.div(X, X_max) # divides two tensors\n",
        "xPredicted = torch.div(xPredicted, xPredicted_max)\n",
        "y = y / 100"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xubpmmQhUbG7"
      },
      "source": [
        "class Neural_Network(nn.Module)\n",
        "  def __init__(self, ):\n",
        "    super(Neural_Network, self).__init__()\n",
        "    # parameters\n",
        "    # TODO: paramteres can be parameterized instead of declaring them here\n",
        "    self.inputSize = 2\n",
        "    self.outputSize = 1\n",
        "    self.hiddenSize = 3\n",
        "\n",
        "    #weights\n",
        "    self.W1 = torch.randn(self.inputSize, self.hiddenSize)\n",
        "    self.W2 = torch.randn(self.hiddenSize, self.outputSize)\n",
        "\n",
        "  def forward(self, X):\n",
        "    self.z = torch.matmul(X, self.W1) # apply weights to the input\n",
        "    self.z2 = self.sigmoid(self.z) # apply activation function to matrix\n",
        "    self.z3 = torch.matmul(self.z2, self.W2) # apply weights to the values from the hidden layer\n",
        "    o = self.sigmoid(self.z3) # apple the activation function\n",
        "    return o\n",
        "\n",
        "  def sigmoid(self, s):\n",
        "    return 1 / (1 + torch.exp(-s))\n",
        "    \n",
        "  def sigmoidDeriv(self, s):\n",
        "    return s * (1 - s)\n",
        "  \n",
        "  def backward(self, X, y, o):\n",
        "    self.o_error = y - o # error\n",
        "    self.o_delta = self.o_error * self.sigmoidDeriv(o)\n",
        "    self.z2_error = torch.matmul(self.o_delta, torch.t(self.W2)) # what's torch.t\n",
        "    self.z2_delta = self.z2_error * self.sigmoidDeriv(self.z2)\n",
        "    self.W1 += torch.matmul(torch.t(X), self.z2_delta)\n",
        "    self.W2 += torch.matmul(torch.t(self.z2), self.o_delta)\n",
        "\n",
        "  def train(self, X, y):\n",
        "    # forward + backward pass for training\n",
        "    o = self.forward(X)\n",
        "    self.backward(X, y, o)\n",
        "\n",
        "  def saveWeights(self, model):\n",
        "    # we will use the PyTorch internal storage functions\n",
        "    torch.save(mode, \"NN\")\n",
        "    # you can reload the model with all the weights with:\n",
        "    # torch.load(\"NN\")\n",
        "\n",
        "  def predict(self):\n",
        "    print (\"Predicted data based on trained weights: \")\n",
        "    print (\"Input (scaled): \\n\" + str(xPredicted))\n",
        "    print (\"Output: \\n\" + str(self.forward(xPredicted)))\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}