Part 4 - Fashion-MNIST (Exercises).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classifying Fashion-MNIST\n",
    "\n",
    "Now it's your turn to build and train a neural network. You'll be using the [Fashion-MNIST dataset](https://github.com/zalandoresearch/fashion-mnist), a drop-in replacement for the MNIST dataset. MNIST is actually quite trivial with neural networks where you can easily achieve better than 97% accuracy. Fashion-MNIST is a set of 28x28 greyscale images of clothes. It's more complex than MNIST, so it's a better representation of the actual performance of your network, and a better representation of datasets you'll use in the real world.\n",
    "\n",
    "<img src='assets/fashion-mnist-sprite.png' width=500px>\n",
    "\n",
    "In this notebook, you'll build your own neural network. For the most part, you could just copy and paste the code from Part 3, but you wouldn't be learning. It's important for you to write the code yourself and get it to work. Feel free to consult the previous notebooks though as you work through this.\n",
    "\n",
    "First off, let's load the dataset through torchvision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torchvision import datasets, transforms\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# Define a transform to normalize the data\n",
    "transform = transforms.Compose([transforms.ToTensor(),\n",
    "                                transforms.Normalize((0.5,), (0.5,))])\n",
    "# Download and load the training data\n",
    "trainset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=True, train=True, transform=transform)\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)\n",
    "\n",
    "# Download and load the test data\n",
    "testset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=True, train=False, transform=transform)\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Helper Fucntions\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from torch import nn, optim\n",
    "from torch.autograd import Variable\n",
    "\n",
    "\n",
    "def test_network(net, trainloader):\n",
    "\n",
    "    criterion = nn.MSELoss()\n",
    "    optimizer = optim.Adam(net.parameters(), lr=0.001)\n",
    "\n",
    "    dataiter = iter(trainloader)\n",
    "    images, labels = dataiter.next()\n",
    "\n",
    "    # Create Variables for the inputs and targets\n",
    "    inputs = Variable(images)\n",
    "    targets = Variable(images)\n",
    "\n",
    "    # Clear the gradients from all Variables\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # Forward pass, then backward pass, then update weights\n",
    "    output = net.forward(inputs)\n",
    "    loss = criterion(output, targets)\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "    return True\n",
    "\n",
    "\n",
    "def imshow(image, ax=None, title=None, normalize=True):\n",
    "    \"\"\"Imshow for Tensor.\"\"\"\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots()\n",
    "    image = image.numpy().transpose((1, 2, 0))\n",
    "\n",
    "    if normalize:\n",
    "        mean = np.array([0.485, 0.456, 0.406])\n",
    "        std = np.array([0.229, 0.224, 0.225])\n",
    "        image = std * image + mean\n",
    "        image = np.clip(image, 0, 1)\n",
    "\n",
    "    ax.imshow(image)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.spines['bottom'].set_visible(False)\n",
    "    ax.tick_params(axis='both', length=0)\n",
    "    ax.set_xticklabels('')\n",
    "    ax.set_yticklabels('')\n",
    "\n",
    "    return ax\n",
    "\n",
    "\n",
    "def view_recon(img, recon):\n",
    "    ''' Function for displaying an image (as a PyTorch Tensor) and its\n",
    "        reconstruction also a PyTorch Tensor\n",
    "    '''\n",
    "\n",
    "    fig, axes = plt.subplots(ncols=2, sharex=True, sharey=True)\n",
    "    axes[0].imshow(img.numpy().squeeze())\n",
    "    axes[1].imshow(recon.data.numpy().squeeze())\n",
    "    for ax in axes:\n",
    "        ax.axis('off')\n",
    "        ax.set_adjustable('box-forced')\n",
    "\n",
    "def view_classify(img, ps, version=\"MNIST\"):\n",
    "    ''' Function for viewing an image and it's predicted classes.\n",
    "    '''\n",
    "    ps = ps.data.numpy().squeeze()\n",
    "\n",
    "    fig, (ax1, ax2) = plt.subplots(figsize=(6,9), ncols=2)\n",
    "    ax1.imshow(img.resize_(1, 28, 28).numpy().squeeze())\n",
    "    ax1.axis('off')\n",
    "    ax2.barh(np.arange(10), ps)\n",
    "    ax2.set_aspect(0.1)\n",
    "    ax2.set_yticks(np.arange(10))\n",
    "    if version == \"MNIST\":\n",
    "        ax2.set_yticklabels(np.arange(10))\n",
    "    elif version == \"Fashion\":\n",
    "        ax2.set_yticklabels(['T-shirt/top',\n",
    "                            'Trouser',\n",
    "                            'Pullover',\n",
    "                            'Dress',\n",
    "                            'Coat',\n",
    "                            'Sandal',\n",
    "                            'Shirt',\n",
    "                            'Sneaker',\n",
    "                            'Bag',\n",
    "                            'Ankle Boot'], size='small');\n",
    "    ax2.set_title('Class Probability')\n",
    "    ax2.set_xlim(0, 1.1)\n",
    "\n",
    "    plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we can see one of the images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "image, label = next(iter(trainloader))\n",
    "imshow(image[0,:]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building the network\n",
    "\n",
    "Here you should define your network. As with MNIST, each image is 28x28 which is a total of 784 pixels, and there are 10 classes. You should include at least one hidden layer. We suggest you use ReLU activations for the layers and to return the logits or log-softmax from the forward pass. It's up to you how many layers you add and the size of those layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Define your network architecture here\n",
    "model = nn.Sequential(nn.Linear(784, 128),\n",
    "                      nn.ReLU(),\n",
    "                      nn.Linear(128, 64),\n",
    "                      nn.ReLU(),\n",
    "                      nn.Linear(64, 10),\n",
    "                      nn.LogSoftmax(dim=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Classifier(nn.Module):\n",
    "    def __init__(self, n_input=784, n_hidden_1=256, n_hidden_2=128, n_hidden_3=64, n_outputs=10):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(n_input, n_hidden_1)\n",
    "        self.fc2 = nn.Linear(n_hidden_1, n_hidden_2)\n",
    "        self.fc3 = nn.Linear(n_hidden_2, n_hidden_3)\n",
    "        self.fc4 = nn.Linear(n_hidden_3, n_outputs)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # Flattening Inside forward\n",
    "        x = x.view(x.shape[0], -1)\n",
    "        \n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        x = F.log_softmax(self.fc4(x), dim=1)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Classifier(\n",
       "  (fc1): Linear(in_features=784, out_features=256, bias=True)\n",
       "  (fc2): Linear(in_features=256, out_features=128, bias=True)\n",
       "  (fc3): Linear(in_features=128, out_features=64, bias=True)\n",
       "  (fc4): Linear(in_features=64, out_features=10, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Classifier()\n",
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train the network\n",
    "\n",
    "Now you should create your network and train it. First you'll want to define [the criterion](http://pytorch.org/docs/master/nn.html#loss-functions) ( something like `nn.CrossEntropyLoss`) and [the optimizer](http://pytorch.org/docs/master/optim.html) (typically `optim.SGD` or `optim.Adam`).\n",
    "\n",
    "Then write the training code. Remember the training pass is a fairly straightforward process:\n",
    "\n",
    "* Make a forward pass through the network to get the logits \n",
    "* Use the logits to calculate the loss\n",
    "* Perform a backward pass through the network with `loss.backward()` to calculate the gradients\n",
    "* Take a step with the optimizer to update the weights\n",
    "\n",
    "By adjusting the hyperparameters (hidden units, learning rate, etc), you should be able to get the training loss below 0.4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Create the network, define the criterion and optimizer\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=0.003)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training loss: 0.514065888819537\n",
      "Training loss: 0.39504971104199443\n",
      "Training loss: 0.35521772785036804\n",
      "Training loss: 0.3353806545119931\n",
      "Training loss: 0.3194234316219399\n"
     ]
    }
   ],
   "source": [
    "# TODO: Train the network here\n",
    "epochs = 5\n",
    "for e in range(epochs):\n",
    "    running_loss = 0\n",
    "    for images, labels in trainloader:\n",
    "        \n",
    "        # Flatten MNIST images into a 784 long vector\n",
    "        # We are flattening inside the forward here\n",
    "        #images = images.view(images.shape[0], -1)\n",
    "    \n",
    "        # TODO: Training pass\n",
    "        # Set Gradients to zero after each step\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        # Pass the data into model\n",
    "        output = model(images)\n",
    "        \n",
    "        # Calculate loss\n",
    "        loss = criterion(output, labels)\n",
    "        \n",
    "        # Backward Propagation\n",
    "        loss.backward()\n",
    "        \n",
    "        # Update Step\n",
    "        optimizer.step()\n",
    "        running_loss += loss.item()\n",
    "    else:\n",
    "        print(f\"Training loss: {running_loss/len(trainloader)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x648 with 2 Axes>"
      ]
     },
     "metadata": {
      "image/png": {
       "height": 216,
       "width": 424
      },
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "%config InlineBackend.figure_format = 'retina'\n",
    "\n",
    "# Test out your network!\n",
    "\n",
    "dataiter = iter(testloader)\n",
    "images, labels = dataiter.next()\n",
    "img = images[0]\n",
    "# Convert 2D image to 1D vector\n",
    "img = img.resize_(1, 784)\n",
    "\n",
    "# Turn off gradients to speed up this part\n",
    "with torch.no_grad():\n",
    "    logps = model(img)\n",
    "\n",
    "# TODO: Calculate the class probabilities (softmax) for img\n",
    "ps = torch.exp(logps)\n",
    "\n",
    "# Plot the image and probabilities\n",
    "view_classify(img.resize_(1, 28, 28), ps, version='Fashion')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}