Tensorboard.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.stack()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# transforms\n",
    "transform = transforms.Compose(\n",
    "    [transforms.ToTensor(),\n",
    "    transforms.Normalize((0.5,), (0.5,))])\n",
    "\n",
    "# datasets\n",
    "trainset = torchvision.datasets.FashionMNIST('./data',\n",
    "    download=True,\n",
    "    train=True,\n",
    "    transform=transform)\n",
    "testset = torchvision.datasets.FashionMNIST('./data',\n",
    "    download=True,\n",
    "    train=False,\n",
    "    transform=transform)\n",
    "\n",
    "# dataloaders\n",
    "trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,\n",
    "                                        shuffle=True, num_workers=2)\n",
    "\n",
    "\n",
    "testloader = torch.utils.data.DataLoader(testset, batch_size=4,\n",
    "                                        shuffle=False, num_workers=2)\n",
    "\n",
    "# constant for classes\n",
    "classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',\n",
    "        'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')\n",
    "\n",
    "# helper function to show an image\n",
    "# (used in the `plot_classes_preds` function below)\n",
    "def matplotlib_imshow(img, one_channel=False):\n",
    "    if one_channel:\n",
    "        img = img.mean(dim=0)\n",
    "    img = img / 2 + 0.5     # unnormalize\n",
    "    npimg = img.numpy()\n",
    "    if one_channel:\n",
    "        plt.imshow(npimg, cmap=\"Greys\")\n",
    "    else:\n",
    "        plt.imshow(np.transpose(npimg, (1, 2, 0)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Net, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(1, 6, 5)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
    "        self.fc1 = nn.Linear(16 * 4 * 4, 120)\n",
    "        self.fc2 = nn.Linear(120, 84)\n",
    "        self.fc3 = nn.Linear(84, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        x = x.view(-1, 16 * 4 * 4)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "net = Net()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "# default `log_dir` is \"runs\" - we'll be more specific here\n",
    "writer = SummaryWriter('runs/fashion_mnist_experiment_1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": [
    "# get some random training images\n",
    "dataiter = iter(trainloader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "# create grid of images\n",
    "img_grid = torchvision.utils.make_grid(images)\n",
    "\n",
    "# show images\n",
    "matplotlib_imshow(img_grid, one_channel=True)\n",
    "\n",
    "# write to tensorboard\n",
    "writer.add_image('four_fashion_mnist_images', img_grid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !tensorboard --logdir=runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([9, 0, 0,  ..., 3, 0, 5])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trainset.targets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer.add_graph(net, images)\n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "warning: Embedding dir exists, did you set global_step for add_embedding()?\n"
     ]
    }
   ],
   "source": [
    "# helper function\n",
    "def select_n_random(data, labels, n=100):\n",
    "    '''\n",
    "    Selects n random datapoints and their corresponding labels from a dataset\n",
    "    '''\n",
    "    assert len(data) == len(labels)\n",
    "\n",
    "    perm = torch.randperm(len(data))\n",
    "    return data[perm][:n], labels[perm][:n]\n",
    "\n",
    "# select random images and their target indices\n",
    "images, labels = select_n_random(trainset.data, trainset.targets)\n",
    "\n",
    "# get the class labels for each image\n",
    "class_labels = [classes[lab] for lab in labels]\n",
    "\n",
    "# log embeddings\n",
    "features = images.view(-1, 28 * 28)\n",
    "writer.add_embedding(features,\n",
    "                    metadata=class_labels,\n",
    "                    label_img=images.unsqueeze(1))\n",
    "writer.close()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# helper functions\n",
    "\n",
    "def images_to_probs(net, images):\n",
    "    '''\n",
    "    Generates predictions and corresponding probabilities from a trained\n",
    "    network and a list of images\n",
    "    '''\n",
    "    output = net(images)\n",
    "    # convert output probabilities to predicted class\n",
    "    _, preds_tensor = torch.max(output, 1)\n",
    "    preds = np.squeeze(preds_tensor.numpy())\n",
    "    return preds, [F.softmax(el, dim=0)[i].item() for i, el in zip(preds, output)]\n",
    "\n",
    "\n",
    "def plot_classes_preds(net, images, labels):\n",
    "    '''\n",
    "    Generates matplotlib Figure using a trained network, along with images\n",
    "    and labels from a batch, that shows the network's top prediction along\n",
    "    with its probability, alongside the actual label, coloring this\n",
    "    information based on whether the prediction was correct or not.\n",
    "    Uses the \"images_to_probs\" function.\n",
    "    '''\n",
    "    preds, probs = images_to_probs(net, images)\n",
    "    # plot the images in the batch, along with predicted and true labels\n",
    "    fig = plt.figure(figsize=(12, 48))\n",
    "    for idx in np.arange(4):\n",
    "        ax = fig.add_subplot(1, 4, idx+1, xticks=[], yticks=[])\n",
    "        matplotlib_imshow(images[idx], one_channel=True)\n",
    "        ax.set_title(\"{0}, {1:.1f}%\\n(label: {2})\".format(\n",
    "            classes[preds[idx]],\n",
    "            probs[idx] * 100.0,\n",
    "            classes[labels[idx]]),\n",
    "                    color=(\"green\" if preds[idx]==labels[idx].item() else \"red\"))\n",
    "    return fig\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Finished Training\n"
     ]
    }
   ],
   "source": [
    "running_loss = 0.0\n",
    "for epoch in range(1):  # loop over the dataset multiple times\n",
    "\n",
    "    for i, data in enumerate(trainloader, 0):\n",
    "\n",
    "        # get the inputs; data is a list of [inputs, labels]\n",
    "        inputs, labels = data\n",
    "\n",
    "        # zero the parameter gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # forward + backward + optimize\n",
    "        outputs = net(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        running_loss += loss.item()\n",
    "        if i % 1000 == 999:    # every 1000 mini-batches...\n",
    "\n",
    "            # ...log the running loss\n",
    "            writer.add_scalar('training loss',\n",
    "                            running_loss / 1000,\n",
    "                            epoch * len(trainloader) + i)\n",
    "\n",
    "            # ...log a Matplotlib Figure showing the model's predictions on a\n",
    "            # random mini-batch\n",
    "            writer.add_figure('predictions vs. actuals',\n",
    "                            plot_classes_preds(net, inputs, labels),\n",
    "                            global_step=epoch * len(trainloader) + i)\n",
    "            running_loss = 0.0\n",
    "print('Finished Training')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. gets the probability predictions in a test_size x num_classes Tensor\n",
    "# 2. gets the preds in a test_size Tensor\n",
    "# takes ~10 seconds to run\n",
    "class_probs = []\n",
    "class_preds = []\n",
    "with torch.no_grad():\n",
    "    for data in testloader:\n",
    "        images, labels = data\n",
    "        output = net(images)\n",
    "        class_probs_batch = [F.softmax(el, dim=0) for el in output]\n",
    "        _, class_preds_batch = torch.max(output, 1)\n",
    "\n",
    "        class_probs.append(class_probs_batch)\n",
    "        class_preds.append(class_preds_batch)\n",
    "\n",
    "test_probs = torch.cat([torch.stack(batch) for batch in class_probs])\n",
    "test_preds = torch.cat(class_preds)\n",
    "\n",
    "# helper function\n",
    "def add_pr_curve_tensorboard(class_index, test_probs, test_preds, global_step=0):\n",
    "    '''\n",
    "    Takes in a \"class_index\" from 0 to 9 and plots the corresponding\n",
    "    precision-recall curve\n",
    "    '''\n",
    "    tensorboard_preds = test_preds == class_index\n",
    "    tensorboard_probs = test_probs[:, class_index]\n",
    "\n",
    "    writer.add_pr_curve(classes[class_index],\n",
    "                        tensorboard_preds,\n",
    "                        tensorboard_probs,\n",
    "                        global_step=global_step)\n",
    "    writer.close()\n",
    "\n",
    "# plot all the pr curves\n",
    "for i in range(len(classes)):\n",
    "    add_pr_curve_tensorboard(i, test_probs, test_preds)"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}