Skip to content

Instantly share code, notes, and snippets.

@xmodar

xmodar/pytorch_tutorial.ipynb

Last active March 14, 2019 18:36
Show Gist options
  • Star 1 You must be signed in to star a gist
  • Fork 1 You must be signed in to fork a gist
  • Save xmodar/b081dcf6c87f9134f29abe3a77be1ab5 to your computer and use it in GitHub Desktop.
Save xmodar/b081dcf6c87f9134f29abe3a77be1ab5 to your computer and use it in GitHub Desktop.
Download ZIP
Basic PyTorch classification tutorial with links and references to useful materials to get started.
Display the source blob
Display the rendered blob
Raw
pytorch_tutorial.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# PyTorch Tutorial by Modar\n",
"\n",
"Basic PyTorch classification tutorial with links and references to useful materials to get started.\n",
"This tutorial was presented on the 6th of August 2018 as part of the [weekly meetings](https://github.com/IVUL-KAUST/GroupReading) of [IVUL-KAUST](http://ivul.kaust.edu.sa) research group.\n",
"\n",
"## Resources\n",
" - [PyTorch Tutorials Page](https://pytorch.org/tutorials/)\n",
" - [PyTorch Documentation](https://pytorch.org/docs/stable/index.html)\n",
" - [PyTorch Examples](https://github.com/pytorch/examples)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## PyTorch as GPU accelerated Numpy\n",
"\n",
" - [Most useful functions](https://pytorch.org/docs/stable/torch.html)\n",
" - [torch.tensor == np.ndarray](https://pytorch.org/docs/stable/tensors.html)\n",
" - default types and auto-casting\n",
" - shapes and dimensions\n",
" - in-place vs output operations\n",
" - [Moving into any GPU](https://pytorch.org/tutorials/beginner/blitz/data_parallel_tutorial.html#sphx-glr-beginner-blitz-data-parallel-tutorial-py)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" ## PyTorch for Deep Learning\n",
" \n",
" - [Autograd](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html#)\n",
" - [Modules](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html) (Neural Networks)\n",
" - [Dealing with Data](https://pytorch.org/tutorials/beginner/data_loading_tutorial.html)\n",
" - [Dataset](https://pytorch.org/docs/stable/data.html#torch.utils.data.Dataset) and [ImageFolder](https://pytorch.org/docs/stable/torchvision/datasets.html#imagefolder)\n",
" - [Transforms](https://pytorch.org/docs/stable/torchvision/transforms.html)\n",
" - [DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader)\n",
" - [Pinned vs. Pageable Memory](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader) (for CPU-GPU data transfer)\n",
" - [Optimizers](https://pytorch.org/docs/stable/optim.html)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## High-Level PyTorch Wrappers\n",
"\n",
"There exists high-level APIs for PyTorch analogous to Keras for Tensorflow such as:\n",
"\n",
" - [torchsample](https://github.com/ncullen93/torchsample)\n",
" - [ignite](https://github.com/pytorch/ignite) (the official one)\n",
" - [torchtools](https://github.com/Time1ess/torchtools)\n",
" - [beauty-net](https://github.com/cms-flash/beauty-net)\n",
" \n",
"Also, it is not that hard to use tensorboard with PyTorch:\n",
"\n",
" - [simple example](https://github.com/yunjey/pytorch-tutorial/tree/master/tutorials/04-utils/tensorboard)\n",
" - [tensorbaordX](https://github.com/lanpa/tensorboardX)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example: Classification on Kaggle's Dogs vs. Cats\n",
"\n",
"You can use this official [~100 lines example](https://github.com/pytorch/examples/blob/master/mnist/main.py) of MNIST classification as a reference.\n",
"\n",
"### Import the relevant libraries\n",
"\n",
"In this example, we will only use `torch` and `torchvision` and we won't be using any high-level API because we want to demonstrate the power of PyTorch at its core. In fact, we will be building something similar to a high-level API ourselves."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import importlib\n",
"import tensorflow as tf # to visualize training summaries with tensorboard\n",
"\n",
"import torch\n",
"from torch import nn\n",
"import torch.nn.functional as F\n",
"from torchvision import transforms, datasets\n",
"\n",
"# for reproducibility\n",
"torch.manual_seed(0)\n",
"\n",
"# a utility function to print the progress of a for-loop\n",
"# don't worry about this bit because it is not part of the tutorial\n",
"# it is recommended that you install `tqdm` package\n",
"def _verbosify(iterable):\n",
" # shows only the iteration number and how many iterations are left\n",
" try:\n",
" len_iterable = len(iterable)\n",
" except Exception:\n",
" len_iterable = None\n",
" for i, element in enumerate(iterable, 1):\n",
" if len_iterable is None:\n",
" print('\\rIteration #{}'.format(i), end='')\n",
" else:\n",
" print('\\rIteration #{} out of {} iterations [Done {:.2f}%]'.format(\n",
" i, len_iterable, 100 * i / len_iterable), end='')\n",
" yield element\n",
" print('\\r', end='', flush=True)\n",
"\n",
"def verbosify(iterable, **kwargs):\n",
" # try to use tqdm (shows the speed and the remaining time left)\n",
" if importlib.util.find_spec('tqdm') is not None:\n",
" tqdm = importlib.import_module('tqdm').tqdm\n",
" if 'file' not in kwargs:\n",
" kwargs['file'] = importlib.import_module('sys').stdout\n",
" if 'leave' not in kwargs:\n",
" kwargs['leave'] = False\n",
" return tqdm(iterable, **kwargs)\n",
" else:\n",
" return iter(_verbosify(iterable))\n",
"\n",
"# try out this example (uncomment to test):\n",
"# for i in verbosify(range(10000000)):\n",
"# pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Prepare the dataset [goal: defining `train_loader` and `valid_loader`]\n",
"\n",
"I strongly recommend that you follow [this tutorial](https://pytorch.org/tutorials/beginner/data_loading_tutorial.html) for a more comprehensive understanding of how to deal with data. \n",
"\n",
"#### 1 - Obtain the dataset\n",
"\n",
"You can find the Dogs vs. Cats dataset [here](https://www.kaggle.com/c/dogs-vs-cats/data). However, you can use your own dataset but to use [ImageFolder](https://pytorch.org/docs/stable/torchvision/datasets.html#imagefolder) you need to make sure that the dataset is in a folder where each subfolder is a class label that contains all the images of that class. There are also utility functions in `torchvision` that downloads common datasets like MNIST and CIFAR10 under `torchvision.datasets` (e.g. `torchvision.datasets.MNIST`).\n",
"\n",
"After you download the Dogs vs. Cats dataset you would get `all.zip` file, unzip it using:\n",
"```shell\n",
"sudo apt-get install unzip\n",
"unzip all.zip -d all\n",
"cd all\n",
"unzip train.zip\n",
"cd train\n",
"```\n",
"\n",
"All the images are named as `[dog|cat].<index>.jpg` but we need to put them in sperate folders `{cat, dog}` as follows:\n",
"```shell\n",
"mkdir dog cat\n",
"mv dog.* dog\n",
"mv cat.* cat\n",
"```\n",
"\n",
"#### 2 - Define the transforms\n",
"\n",
"In PyTorch, we call the input to your model `data` and the output `target`. When we read images from a folder, they are read as `PIL` images but in order to feed them as `data` to our model, they need to be transformed to PyTorch tensors with correct size and normalization. This is why we will create a list of transformation functions for the images, each of which will operate on the output of the previous function while the first function will operate on a single `PIL` image. You can also create transformation functions for the output labels called `target_transform` if needed."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"train_transform = transforms.Compose([\n",
" transforms.Resize(224), # takes PIL image as input and outputs PIL image\n",
" transforms.RandomResizedCrop(224), # takes PIL image as input and outputs PIL image\n",
" transforms.RandomHorizontalFlip(), # takes PIL image as input and outputs PIL image\n",
" transforms.ToTensor(), # takes PIL image as input and outputs torch.tensor\n",
" transforms.Normalize(mean=[0.4280, 0.4106, 0.3589], # takes tensor and outputs tensor\n",
" std=[0.2737, 0.2631, 0.2601]), # see next step for mean and std\n",
" ])\n",
"valid_transform = transforms.Compose([ # for validation we don't randomize or augment\n",
" transforms.Resize(224),\n",
" transforms.CenterCrop(224),\n",
" transforms.ToTensor(),\n",
" transforms.Normalize(mean=[0.4280, 0.4106, 0.3589],\n",
" std=[0.2737, 0.2631, 0.2601]), \n",
" ])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### 3 - Create the dataset"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# Just implement __getitem__ and __len__\n",
"class DummyDataset(torch.utils.data.Dataset):\n",
" def __init__(self, size=(3, 224, 224), num_samples=1000, num_classes=3):\n",
" self.images = torch.randn(num_samples, *size)\n",
" self.labels = torch.randint(0, num_classes, (num_samples,))\n",
" # this dataset, doesn't need transforms\n",
" # because it is already in the correct size and format\n",
"\n",
" def __getitem__(self, index):\n",
" return self.images[index, ...], self.labels[index]\n",
"\n",
" def __len__(self):\n",
" return self.images.size(0)\n",
"\n",
"# Or, we can use `torchvision.datasets.ImageFolder`\n",
"dataset = datasets.ImageFolder(root='./all/train/',\n",
" transform=train_transform)\n",
"\n",
"# here you should split this dataset into training and validation\n",
"def random_split(dataset, split_frac):\n",
" dataset_length = len(dataset)\n",
" train_length = int(dataset_length * (1 - split_frac))\n",
" valid_length = dataset_length - train_length\n",
" train_set, valid_set = torch.utils.data.random_split(dataset, [train_length, valid_length])\n",
" return train_set, valid_set\n",
"\n",
"split_frac = 0.1 # the ratio of images in the validation set\n",
"train_set, valid_set = random_split(dataset, split_frac)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"# getting the mean and std of the images (assuming that you have enough memory)\n",
"\n",
"# pixels_list = [img.view(3, -1) for img, label in \\ # this will take a while\n",
"# datasets.ImageFolder(root='all/train', transform=valid_transform)] \n",
"# pixels = torch.cat(pixels_list, dim=-1)\n",
"# pixels_mean = pixels.mean(dim=-1)\n",
"# pixels_std = pixels.std(dim=-1)\n",
"# print(pixels_mean) # Out: tensor([0.4280, 0.4106, 0.3589])\n",
"# print(pixels_std) # Out: tensor([0.2737, 0.2631, 0.2601])\n",
"\n",
"# if you don't have sufficient memory, you can compute mean as a running average\n",
"# and std as described here: https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### 4 - Define the loaders"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"# create the torch.utils.data.DataLoader which will do the loading\n",
"def data_loader(dataset, batch_size, train, cuda):\n",
" return torch.utils.data.DataLoader(dataset,\n",
" batch_size=batch_size,\n",
" pin_memory=cuda,\n",
" num_workers=4 if cuda else 0,\n",
" shuffle=not train,\n",
" drop_last=train)\n",
"\n",
"train_loader = data_loader(train_set, 128, train=True, cuda=True)\n",
"valid_loader = data_loader(valid_set, 256, train=False, cuda=True)\n",
"# Note: look up the rest of the parameters of DataLoader\n",
"# some of the interesting ones are `sampler` and `collate_fn`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Define the model [goal: defining `Net`]\n",
"\n",
"Please, refer to the official implementation of AlexNet [here](https://github.com/pytorch/vision/blob/master/torchvision/models/alexnet.py) for a nicer style of defining an `nn.Module` that uses `nn.Sequential` which itself is a subclass of `nn.Module`. It will introduce you to `nn.Sequential` and the concept of defining a module using submodules."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"class Net(nn.Module):\n",
" def __init__(self):\n",
" super().__init__()\n",
" # define all the parameters of the model here\n",
" # Note: All the layers and modules have to be direct\n",
" # attributes of Net to be included in training (e.g. self.conv1).\n",
" # To add them manually: `self.add_module(name, module)`.\n",
" self.conv1 = nn.Conv2d(3, 32, kernel_size=5)\n",
" self.conv2 = nn.Conv2d(32, 64, kernel_size=5)\n",
" self.conv2_drop = nn.Dropout2d()\n",
" self.conv3 = nn.Conv2d(64, 64, kernel_size=5)\n",
" self.conv4 = nn.Conv2d(64, 20, kernel_size=5)\n",
" self.fc1 = nn.Linear(2000, 1024) # assumes the input is 224x224\n",
" self.fc2 = nn.Linear(1024, 10)\n",
"\n",
" def forward(self, x):\n",
" # define the forward pass here\n",
" # Note: PyTorch will complain if you tried to do operations between tensors that don't\n",
" # have the same dtype and/or device but it will allow scalar tensor operations.\n",
" # Be wary of operations using scalars because it is a big source of errors.\n",
" # Native Python scalars are mostly fine but Numpy scalars are problematic:\n",
" # E.g., `np.array([1.])[0] * torch.tensor(2, device='cuda')` will be in 'cpu'.\n",
" # Always put the scalars in `torch.tensor` to know when you are mixing stuff.\n",
" x = F.relu(F.max_pool2d(self.conv1(x), 2))\n",
" x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n",
" x = F.relu(F.max_pool2d(self.conv3(x), 2))\n",
" x = F.relu(F.max_pool2d(self.conv4(x), 2))\n",
" x = x.view(x.shape[0], -1)\n",
" x = F.relu(self.fc1(x))\n",
" x = F.dropout(x, training=self.training)\n",
" x = self.fc2(x)\n",
" return x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Implement the training procedure [goal: defining `full_epoch()`]\n",
"\n",
"We need to implement a function, called `full_epoch()`, that performs a single complete epoch on a given dataset and returns some computed metrics (e.g., loss and accuracy). It will take as input the model, the data loader, the device to do the operations on and optionally an optimizer. If the optimizer is provided, it will do a training epoch, otherwise it will do a validation epoch. Here, we will also implement a helper function called `process()`, for modularity purposes only, that processes a single input batch at a time and it will be called by `full_epoch()` at each iteration. Usually, you would only need to modify `process()`."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"def softmax_cross_entropy(output, target):\n",
" # more efficient than `F.cross_entropy(F.softmax(output), target)`\n",
" return F.nll_loss(F.log_softmax(output, dim=1), target)\n",
"\n",
"def accuracy(output, target):\n",
" predictions = output.max(1, keepdim=True)[1]\n",
" return predictions.eq(target.view_as(predictions)).sum()\n",
"\n",
"def process(model, data, target, optimizer=None):\n",
" '''Perform the forward and backward passes on the given data.\n",
" \n",
" Args:\n",
" model: An `nn.Module` or a function to process `data`.\n",
" data: The desired input to `model` (e.g., a batch of images).\n",
" target: The desired output of `model` (e.g., ground truth labels).\n",
" optimizer: To perform the backward pass.\n",
" \n",
" Returns:\n",
" A `dict` of collected metrics.\n",
" '''\n",
" # compute the loss\n",
" output = model(data) # logits\n",
" loss = softmax_cross_entropy(output, target)\n",
" \n",
" # if training, update the weights\n",
" if optimizer is not None:\n",
" # you need to zero_out the gradients of all the parameters\n",
" optimizer.zero_grad()\n",
" # accumlate the gradients with a backward pass\n",
" loss.backward()\n",
" # update the parameters with the gradients\n",
" optimizer.step()\n",
" \n",
" # save the metrics\n",
" metrics = {\n",
" 'loss': loss.item() * len(data),\n",
" 'accuracy': accuracy(output, target).item(),\n",
" }\n",
" return metrics\n",
"\n",
"def full_epoch(model, data_loader, device, optimizer=None):\n",
" '''Perform a single epoch.\n",
" \n",
" Args:\n",
" model: An `nn.Module` or a function to process `data`.\n",
" data_loader: A 'torch.utils.data.DataLoader'.\n",
" device: On which device to perfrom the epoch.\n",
" \n",
" Returns:\n",
" A `dict` of collected metrics.\n",
" '''\n",
" # Change model.training to True and False accordingly\n",
" if optimizer is None:\n",
" model.eval()\n",
" else:\n",
" model.train()\n",
" model.to(device)\n",
" total_count = 0\n",
" accumulated_metrics = {}\n",
" for data, target in verbosify(data_loader):\n",
" # process the batch [data (images) and target (labels)]\n",
" metrics = process(model, data.to(device), target.to(device), optimizer)\n",
" # accumlate the metrics\n",
" total_count += len(data)\n",
" for metric, value in metrics.items():\n",
" if metric not in accumulated_metrics:\n",
" accumulated_metrics[metric] = 0\n",
" accumulated_metrics[metric] += value\n",
" # compute the averaged metrics\n",
" for metric in accumulated_metrics:\n",
" accumulated_metrics[metric] /= total_count\n",
" return accumulated_metrics"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Train a model [goal: defining `train()` and running it]\n",
"\n",
"But first, we will implement a generic `train()` function."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def train(model, device, num_epochs, optimizer, train_loader, valid_loader,\n",
" scheduler=None, patience=10, load=None, save=None, log_dir=None, restart=False):\n",
" '''Train a model for a certain number of epochs.\n",
" \n",
" Args:\n",
" model: An `nn.Module` or a function to process the batches form the loaders.\n",
" device: In which device to do the training.\n",
" num_epochs: Number of epochs to train.\n",
" optimizer: An `torch.optim.Optimizer` (e.g. SGD).\n",
" train_loader: The `torch.utils.data.DataLoader` for the training dataset.\n",
" valid_loader: The `torch.utils.data.DataLoader` for the validation dataset.\n",
" scheduler: The learning rate scheduler.\n",
" patience: The number of bad epochs to wait before early termination.\n",
" load: Reinitialize the model and its hyper-parameters from this `*.pt` checkpoint file.\n",
" save: The `*.pt` checkpoint file to save all the parameters of the trained model.\n",
" log_dir: The directory to which we want to save tensorboard summaries.\n",
" restart: Whether to remove `log_dir` and `load` before starting the function.\n",
" \n",
" Returns:\n",
" The best state of the model during training (at the maximum validation loss).\n",
" '''\n",
" # restart if desired by removing old files\n",
" if restart:\n",
" if log_dir is not None and os.path.exists(log_dir):\n",
" rmtree(log_dir)\n",
" if load is not None and os.path.exists(load):\n",
" os.remove(load)\n",
"\n",
" # try to resume from a checkpoint file if `load` was provided\n",
" if load is not None:\n",
" try:\n",
" best_state = torch.load(load)\n",
" model.load_state_dict(best_state['model'])\n",
" optimizer.load_state_dict(best_state['optimizer'])\n",
" scheduler.load_state_dict(best_state['scheduler'])\n",
" except FileNotFoundError:\n",
" msg = 'Couldn\\'t find checkpoint file! {} (training with random initialization)'\n",
" print(msg.format(load))\n",
" load = None\n",
"\n",
" # otherwise, start from the current initialization\n",
" if load is None:\n",
" best_state = {\n",
" 'epoch': -1,\n",
" 'model': model.state_dict(),\n",
" 'optimizer': optimizer.state_dict(),\n",
" 'scheduler': scheduler.state_dict(),\n",
" 'loss': float('inf'),\n",
" }\n",
" \n",
" model.to(device)\n",
" num_bad_epochs = 0\n",
" for epoch in range(best_state['epoch'] + 1, num_epochs):\n",
" # train and validate\n",
" train_metrics = full_epoch(model, train_loader, device, optimizer)\n",
" valid_metrics = full_epoch(model, valid_loader, device) # will not do backward pass\n",
"\n",
" # get the current learing rate\n",
" learning_rate = optimizer.param_groups[0]['lr']\n",
" # Note: an nn.Module can have multiple param_groups\n",
" # each of which can be assigned a different learning rate\n",
" # but by default we have a single param_group.\n",
"\n",
" # reduce the learning rate according to the `scheduler` policy\n",
" if scheduler is not None:\n",
" scheduler.step(valid_metrics['loss'])\n",
"\n",
" # print the progress\n",
" print('Epoch #{}: [train: {:.2e} > {:.2f}%][valid: {:.2e} > {:.2f}%] @ {:.2e}'.format(\n",
" epoch, train_metrics['loss'], 100 * train_metrics['accuracy'],\n",
" valid_metrics['loss'], 100 * valid_metrics['accuracy'], learning_rate,\n",
" ))\n",
"\n",
" # save tensorboard summaries\n",
" if log_dir is not None:\n",
" # create the summary writer only the first time\n",
" if not hasattr(log_dir, 'add_summary'):\n",
" log_dir = tf.summary.FileWriter(log_dir)\n",
" summaries = {\n",
" 'learning_rate': learning_rate,\n",
" }\n",
" summaries.update({'train/' + name: value for name, value in train_metrics.items()})\n",
" summaries.update({'valid/' + name: value for name, value in valid_metrics.items()})\n",
" values = [tf.Summary.Value(tag=k, simple_value=v) for k, v in summaries.items()]\n",
" log_dir.add_summary(tf.Summary(value=values), epoch)\n",
" log_dir.flush()\n",
" \n",
" # save the model to disk if it has improved\n",
" if best_state['loss'] < valid_metrics['loss']:\n",
" num_bad_epochs += 1\n",
" else:\n",
" num_bad_epochs = 0\n",
" best_state = {\n",
" 'epoch': epoch,\n",
" 'model': model.state_dict(),\n",
" 'optimizer': optimizer.state_dict(),\n",
" 'scheduler': scheduler.state_dict(),\n",
" 'loss': valid_metrics['loss'],\n",
" }\n",
" if save is not None:\n",
" torch.save(best_state, save)\n",
"\n",
" # do early stopping\n",
" if num_bad_epochs >= patience:\n",
" print('Validation loss didn\\'t improve for {} iterations!'.format(patience))\n",
" print('[Early stopping]')\n",
" break\n",
"\n",
" # close the summary writer if created\n",
" if log_dir is not None:\n",
" if hasattr(log_dir, 'close'):\n",
" log_dir.close()\n",
"\n",
" return best_state"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Then, we will initialize a model with some hyper-parameters and start the training."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Couldn't find checkpoint file! ./all/model.pt (training without reinitialization)\n",
"Epoch #0: [train: 8.01e-01 > 51.02%][valid: 6.90e-01 > 54.20%] @ 1.00e-04\n",
"Epoch #1: [train: 6.95e-01 > 54.94%][valid: 6.65e-01 > 61.28%] @ 1.00e-04\n",
"Epoch #2: [train: 6.80e-01 > 57.67%][valid: 6.53e-01 > 61.56%] @ 1.00e-04\n",
"Epoch #3: [train: 6.76e-01 > 58.54%][valid: 6.58e-01 > 60.24%] @ 1.00e-04\n",
"Epoch #4: [train: 6.60e-01 > 60.82%][valid: 6.56e-01 > 60.12%] @ 1.00e-04\n",
"Epoch #5: [train: 6.51e-01 > 62.10%][valid: 6.34e-01 > 64.76%] @ 1.00e-04\n",
"Epoch #6: [train: 6.43e-01 > 63.32%][valid: 6.21e-01 > 65.52%] @ 1.00e-04\n",
"Epoch #7: [train: 6.36e-01 > 64.58%][valid: 6.04e-01 > 68.04%] @ 1.00e-04\n",
"Epoch #8: [train: 6.29e-01 > 65.19%][valid: 6.06e-01 > 68.40%] @ 1.00e-04\n",
"Epoch #9: [train: 6.25e-01 > 65.35%][valid: 6.03e-01 > 68.16%] @ 1.00e-04\n",
"\n",
"Tensorboard snapshot:\n"
]
},
{
"data": {
"text/html": [
"<img src=\"data:image/png;base64,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\" width=\"500\" height=\"500\"/>"
],
"text/plain": [
"<IPython.core.display.Image object>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# intialize the model and the hyper-parameters\n",
"model = Net()\n",
"num_epochs = 10\n",
"logs = './all/log/model'\n",
"checkpoint = './all/model.pt'\n",
"device = torch.device('cuda:0') # e.g., {'cpu', 'cuda:0', 'cuda:1', ...}\n",
"optimizer = torch.optim.Adam(model.parameters(),\n",
" lr=1e-4, betas=(0.9, 0.999), weight_decay=0.01)\n",
"scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(\n",
" optimizer, 'min', factor=0.2, patience=3, verbose=True)\n",
"\n",
"# train the model\n",
"best_state = train(model, device, num_epochs, optimizer, train_loader, valid_loader,\n",
" scheduler, patience=10, load=checkpoint, save=checkpoint, log_dir=logs, restart=False)\n",
"model.load_state_dict(best_state['model']) # loads the best model acquired during training"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Example conclusion\n",
"\n",
"We implemented a standard deep learning workflow in PyTorch. The steps are (in order):\n",
"\n",
" - Defined `train_loader` and `valid_loader` that loads and transforms our dataset in batches asynchronously\n",
" - Defined a convolutional neural network called `Net`\n",
" - Implemented `full_epoch()` that does a single training or validation epoch depending on whether it was fed an optimizer\n",
" - Implemented `train()`, that uses `full_epoch()`, with early stopping and nice learning rate scheduling\n",
" - Trained a certain initialization of `Net` with hand-picked hyper-parameters\n",
" - Usually, you would end this by a testing phase (i.e., `test()`) but I will leave that to you because now you know how to do it yourself\n",
" \n",
"Final notes and remarks:\n",
"\n",
" - As an exercise, try to think about how to modify `train()` to handle the case when we don't have validation data (i.e., `valid_loader is None`). You will certainly need to do a descent number of changes to incorporate this.\n",
" - If you want to build an API similar to Keras yourself (although you don't need to because such high-level APIs exist already as mentioned at the beginning of this notebook), you will need to add some parameters to `train()` for callbacks that you call before and after training. Then, put all the early stopping and the learning rate scheduling business outside `train()` by implementing them through these callbacks\n",
" - Please, don't hesitate to contact me by finding me on [GitHub](http://github.com/ModarTensai/) if you have any further inquiries"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python [default]",
"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.6.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment