fizzbuzz_SOLVED.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fizzbuzz Lab 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Import Pytorch libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "import torch.optim as optim\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build data classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#0 class is Fizzbuzz\n",
    "#1 class is Fizz\n",
    "#2 class is Buzz\n",
    "#3 class is Same\n",
    "def fizzbuzz(num):\n",
    "    if num%15 == 0:\n",
    "        return (\"FizzBuzz\", 0)\n",
    "    elif num%3 == 0:\n",
    "        return (\"Fizz\", 1)\n",
    "    elif num%5 == 0:\n",
    "        return (\"Buzz\", 2)\n",
    "    else:\n",
    "        return (str(num), 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1.0\n",
      "2 2.0\n",
      "3 Fizz\n",
      "4 4.0\n",
      "5 Buzz\n",
      "6 Fizz\n",
      "7 7.0\n",
      "8 8.0\n",
      "9 Fizz\n",
      "10 Buzz\n",
      "11 11.0\n",
      "12 Fizz\n",
      "13 13.0\n",
      "14 14.0\n",
      "15 FizzBuzz\n"
     ]
    }
   ],
   "source": [
    "ar = np.linspace(1, 15, 15)\n",
    "for num in ar:\n",
    "    print(int(num), fizzbuzz(num)[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build function to generate training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_training_data(range_start, range_end):\n",
    "    inputs = []\n",
    "    outputs = []\n",
    "    for i in range(range_start, range_end+1):\n",
    "        inputs.append([float(char) for char in np.binary_repr(i, width=12)])\n",
    "        outputs.append(fizzbuzz(i)[1])\n",
    "    return (inputs, outputs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generate training data  from range (101, 2000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "(inputs, outputs) = generate_training_data(range_start=101, range_end=2000)\n",
    "print(inputs[0])\n",
    "print(outputs[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generate validation data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "(inputs_validation, outputs_validation) = generate_training_data(range_start=1, range_end=100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build neural network architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.fc1 = nn.Linear(12, 64)\n",
    "        self.fc2 = nn.Linear(64, 64)\n",
    "        self.fc3 = nn.Linear(64, 4)\n",
    "        self.dropout = nn.Dropout(p=0.2)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.dropout(x)\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.dropout(x)\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Initialize our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "net = Net()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train our model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cross entropy loss: 1.4770888090133667|  validation loss: 1.4682809114456177\n",
      "cross entropy loss: 0.9306349158287048|  validation loss: 1.0126183032989502\n",
      "cross entropy loss: 0.5413711667060852|  validation loss: 0.5534065365791321\n",
      "cross entropy loss: 0.3173055350780487|  validation loss: 0.41331806778907776\n",
      "cross entropy loss: 0.23164373636245728|  validation loss: 0.24365457892417908\n",
      "cross entropy loss: 0.161432147026062|  validation loss: 0.19321879744529724\n",
      "cross entropy loss: 0.15248163044452667|  validation loss: 0.13605941832065582\n",
      "cross entropy loss: 0.10284801572561264|  validation loss: 0.14045044779777527\n",
      "cross entropy loss: 0.10317622870206833|  validation loss: 0.12035007774829865\n",
      "cross entropy loss: 0.10317938774824142|  validation loss: 0.06719182431697845\n"
     ]
    }
   ],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(net.parameters(), lr=0.0001)\n",
    "#tranining loop\n",
    "net.train()\n",
    "for i in range(0, 50000):\n",
    "    optimizer.zero_grad()\n",
    "    input_tensor = torch.tensor(inputs, dtype=torch.float)\n",
    "    target_tensor = torch.tensor(outputs)\n",
    "    output = net(input_tensor)\n",
    "    loss = criterion(output, target_tensor)\n",
    "    input_validation_tensor = torch.tensor(inputs_validation, dtype=torch.float)\n",
    "    target_validation_tensor = torch.tensor(outputs_validation)\n",
    "    validation_output = net(input_validation_tensor)\n",
    "    validation_loss = criterion(validation_output, target_validation_tensor)\n",
    "    if i%5000 == 0:\n",
    "        print(\"cross entropy loss: \" +  str(loss.item()) + \"|  validation loss: \" + str(validation_loss.item()))\n",
    "    loss.backward()\n",
    "    optimizer.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Test our model on our validation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.eval()\n",
    "predictions = net(torch.tensor(inputs_validation, dtype=torch.float))\n",
    "predictions = predictions.detach().numpy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Show validation results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1\n",
      "2 2\n",
      "3 Fizz\n",
      "4 4\n",
      "5 Buzz\n",
      "6 Fizz\n",
      "7 7\n",
      "8 8\n",
      "9 Fizz\n",
      "10 Buzz\n",
      "11 11\n",
      "12 Fizz\n",
      "13 13\n",
      "14 14\n",
      "15 FizzBuzz\n",
      "16 16\n",
      "17 17\n",
      "18 Fizz\n",
      "19 19\n",
      "20 Buzz\n",
      "21 Fizz\n",
      "22 22\n",
      "23 23\n",
      "24 Fizz\n",
      "25 Buzz\n",
      "26 26\n",
      "27 Fizz\n",
      "28 28\n",
      "29 29\n",
      "30 FizzBuzz\n",
      "31 31\n",
      "32 32\n",
      "33 Fizz\n",
      "34 34\n",
      "35 Buzz\n",
      "36 Fizz\n",
      "37 37\n",
      "38 38\n",
      "39 Fizz\n",
      "40 Buzz\n",
      "41 41\n",
      "42 Fizz\n",
      "43 43\n",
      "44 44\n",
      "45 FizzBuzz\n",
      "46 46\n",
      "47 47\n",
      "48 Fizz\n",
      "49 49\n",
      "50 Buzz\n",
      "51 Fizz\n",
      "52 52\n",
      "53 53\n",
      "54 Fizz\n",
      "55 Buzz\n",
      "56 56\n",
      "57 Fizz\n",
      "58 58\n",
      "59 59\n",
      "60 FizzBuzz\n",
      "61 61\n",
      "62 62\n",
      "63 Fizz\n",
      "64 64\n",
      "65 Buzz\n",
      "66 Fizz\n",
      "67 67\n",
      "68 68\n",
      "69 Fizz\n",
      "70 Buzz\n",
      "71 71\n",
      "72 Fizz\n",
      "73 73\n",
      "74 74\n",
      "75 FizzBuzz\n",
      "76 76\n",
      "77 77\n",
      "78 Fizz\n",
      "79 79\n",
      "80 Buzz\n",
      "81 Fizz\n",
      "82 82\n",
      "83 83\n",
      "84 Fizz\n",
      "85 Buzz\n",
      "86 86\n",
      "87 Fizz\n",
      "88 88\n",
      "89 89\n",
      "90 FizzBuzz\n",
      "91 91\n",
      "92 92\n",
      "93 Fizz\n",
      "94 94\n",
      "95 Buzz\n",
      "96 Fizz\n",
      "97 97\n",
      "98 98\n",
      "99 Fizz\n",
      "100 Buzz\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, len(predictions)):\n",
    "    prediction = np.argmax(predictions[i])\n",
    "    if prediction == 0:\n",
    "        class_pred = \"FizzBuzz\"\n",
    "    elif prediction == 1:\n",
    "        class_pred = \"Fizz\"\n",
    "    elif prediction == 2:\n",
    "        class_pred = \"Buzz\"\n",
    "    elif prediction == 3:\n",
    "        class_pred = str(i+1)\n",
    "    print(i+1, class_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}