Pytorch/(Pytorch) VISUALIZING MODELS, DATA, AND TRAINING WITH TENSORBOARD.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# VISUALIZING MODELS, DATA, AND TRAINING WITH TENSORBOARD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# From \n",
    "# https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Steps in Tensorboard \n",
    "### 1. Set up TensorBoard.\n",
    "### 2. Write to TensorBoard.\n",
    "### 3. Inspect a model architecture using TensorBoard.\n",
    "### 4. Use TensorBoard to create interactive versions of the visualizations we created in last tutorial, with less code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use Boilerplate code as in the CIFAR-10:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "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",
    "\n",
    "# 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)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model \n",
    "# Minor modifications (images are now one channel instead of three, and 28x28 instead of 32x32:)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up criterion and optimizer\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Set up TensorBoard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "# default `log_dir` is \"runs\" - we'll be more specific here\n",
    "# it creates a runs/fashion_mnist_experiment_1 folder.\n",
    "writer = SummaryWriter('runs/fashion_mnist_experiment_1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Writing to TensorBoard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext tensorboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Reusing TensorBoard on port 6006 (pid 7256), started 0:01:11 ago. (Use '!kill 7256' to kill it.)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "\n",
       "      <iframe id=\"tensorboard-frame-ee9465fe0576b007\" width=\"100%\" height=\"800\" frameborder=\"0\">\n",
       "      </iframe>\n",
       "      <script>\n",
       "        (function() {\n",
       "          const frame = document.getElementById(\"tensorboard-frame-ee9465fe0576b007\");\n",
       "          const url = new URL(\"/\", window.location);\n",
       "          url.port = 6006;\n",
       "          frame.src = url;\n",
       "        })();\n",
       "      </script>\n",
       "  "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%tensorboard --logdir runs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## run tensorboard --logdir=runs\n",
    "## Then go to https://localhost:6006"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Inspect the model using TensorBoard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer.add_graph(net, images)\n",
    "writer.close()"
   ]
  },
  {
   "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
}