diff --git a/.gitignore b/.gitignore
index aa7b675..0f7f31e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,3 +6,8 @@
# ignore sublime-workspace
*.sublime-workspace
+
+# ignore image data
+*assets.tar.gz
+*Cat_Dog_data.zip
+*.pytorch
diff --git a/python/Deep Learning/Deep Learning with PyTorch/.ipynb_checkpoints/Part 4 - Fashion-MNIST (Exercises)-checkpoint.ipynb b/python/Deep Learning/Deep Learning with PyTorch/.ipynb_checkpoints/Part 4 - Fashion-MNIST (Exercises)-checkpoint.ipynb
new file mode 100644
index 0000000..cf2e9d7
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/.ipynb_checkpoints/Part 4 - Fashion-MNIST (Exercises)-checkpoint.ipynb
@@ -0,0 +1,269 @@
+{
+ "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",
+ "\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": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n",
+ "Processing...\n",
+ "Done!\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "from torchvision import datasets, transforms\n",
+ "import helper\n",
+ "\n",
+ "# Define a transform to normalize the data\n",
+ "transform = transforms.Compose([transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 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": "markdown",
+ "metadata": {},
+ "source": [
+ "Here we can see one of the images."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "image, label = next(iter(trainloader))\n",
+ "helper.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",
+ "\n",
+ "# Import modules\n",
+ "from torch import nn, optim\n",
+ "import torch.nn.functional as F"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = nn.Sequential(nn.Linear(784, 256),\n",
+ " nn.ReLU(),\n",
+ " nn.Linear(256, 128),\n",
+ " nn.ReLU(),\n",
+ " nn.Linear(128, 64),\n",
+ " nn.ReLU(),\n",
+ " nn.Linear(64, 10),\n",
+ " nn.LogSoftmax(dim=1))"
+ ]
+ },
+ {
+ "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": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# TODO: Create the network, define the criterion and optimizer\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.Adam(model.parameters(), lr=0.003)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Training loss: 0.5202356389940166\n",
+ "Training loss: 0.3878176898431422\n",
+ "Training loss: 0.3550535404860084\n",
+ "Training loss: 0.3305503525761272\n",
+ "Training loss: 0.31469793412000385\n"
+ ]
+ }
+ ],
+ "source": [
+ "# TODO: Train the network here\n",
+ "epochs = 5\n",
+ "\n",
+ "for e in range(epochs):\n",
+ " running_loss = 0\n",
+ " for image, label in trainloader:\n",
+ " # Flatten images\n",
+ " image = image.view(image.shape[0], -1)\n",
+ " \n",
+ " # Zero the gradients\n",
+ " optimizer.zero_grad()\n",
+ " \n",
+ " # Do a forward pass\n",
+ " log_ps = model.forward(image)\n",
+ " \n",
+ " # Calculate loss\n",
+ " loss = criterion(log_ps, label)\n",
+ " \n",
+ " # Do a backward pass to find gradients\n",
+ " loss.backward()\n",
+ " \n",
+ " # Update weights\n",
+ " optimizer.step()\n",
+ " \n",
+ " running_loss += loss.item()\n",
+ " else:\n",
+ " print(f'Training loss: {running_loss/len(trainloader)}')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 204,
+ "width": 423
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import helper\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",
+ "# TODO: Calculate the class probabilities (softmax) for img\n",
+ "ps = torch.exp(model(img))\n",
+ "\n",
+ "# Plot the image and probabilities\n",
+ "helper.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",
+ "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
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/.ipynb_checkpoints/Untitled-checkpoint.ipynb b/python/Deep Learning/Deep Learning with PyTorch/.ipynb_checkpoints/Untitled-checkpoint.ipynb
new file mode 100644
index 0000000..2fd6442
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/.ipynb_checkpoints/Untitled-checkpoint.ipynb
@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 1 - Tensors in PyTorch (Exercises).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 1 - Tensors in PyTorch (Exercises).ipynb
new file mode 100644
index 0000000..cd956d5
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 1 - Tensors in PyTorch (Exercises).ipynb
@@ -0,0 +1,475 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Introduction to Deep Learning with PyTorch\n",
+ "\n",
+ "In this notebook, you'll get introduced to [PyTorch](http://pytorch.org/), a framework for building and training neural networks. PyTorch in a lot of ways behaves like the arrays you love from Numpy. These Numpy arrays, after all, are just tensors. PyTorch takes these tensors and makes it simple to move them to GPUs for the faster processing needed when training neural networks. It also provides a module that automatically calculates gradients (for backpropagation!) and another module specifically for building neural networks. All together, PyTorch ends up being more coherent with Python and the Numpy/Scipy stack compared to TensorFlow and other frameworks.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Neural Networks\n",
+ "\n",
+ "Deep Learning is based on artificial neural networks which have been around in some form since the late 1950s. The networks are built from individual parts approximating neurons, typically called units or simply \"neurons.\" Each unit has some number of weighted inputs. These weighted inputs are summed together (a linear combination) then passed through an activation function to get the unit's output.\n",
+ "\n",
+ "\n",
+ "\n",
+ "Mathematically this looks like: \n",
+ "\n",
+ "$$\n",
+ "\\begin{align}\n",
+ "y &= f(w_1 x_1 + w_2 x_2 + b) \\\\\n",
+ "y &= f\\left(\\sum_i w_i x_i +b \\right)\n",
+ "\\end{align}\n",
+ "$$\n",
+ "\n",
+ "With vectors this is the dot/inner product of two vectors:\n",
+ "\n",
+ "$$\n",
+ "h = \\begin{bmatrix}\n",
+ "x_1 \\, x_2 \\cdots x_n\n",
+ "\\end{bmatrix}\n",
+ "\\cdot \n",
+ "\\begin{bmatrix}\n",
+ " w_1 \\\\\n",
+ " w_2 \\\\\n",
+ " \\vdots \\\\\n",
+ " w_n\n",
+ "\\end{bmatrix}\n",
+ "$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Tensors\n",
+ "\n",
+ "It turns out neural network computations are just a bunch of linear algebra operations on *tensors*, a generalization of matrices. A vector is a 1-dimensional tensor, a matrix is a 2-dimensional tensor, an array with three indices is a 3-dimensional tensor (RGB color images for example). The fundamental data structure for neural networks are tensors and PyTorch (as well as pretty much every other deep learning framework) is built around tensors.\n",
+ "\n",
+ "\n",
+ "\n",
+ "With the basics covered, it's time to explore how we can use PyTorch to build a simple neural network."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# First, import PyTorch\n",
+ "import torch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def activation(x):\n",
+ " \"\"\" Sigmoid activation function \n",
+ " \n",
+ " Arguments\n",
+ " ---------\n",
+ " x: torch.Tensor\n",
+ " \"\"\"\n",
+ " return 1/(1+torch.exp(-x))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "### Generate some data\n",
+ "torch.manual_seed(7) # Set the random seed so things are predictable\n",
+ "\n",
+ "# Features are 3 random normal variables\n",
+ "features = torch.randn((1, 5))\n",
+ "# True weights for our data, random normal variables again\n",
+ "weights = torch.randn_like(features)\n",
+ "# and a true bias term\n",
+ "bias = torch.randn((1, 1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[-0.9179, -0.4578, -0.7245, 1.2799, -0.9941]])"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "torch.randn_like(torch.randn((1, 5)))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Above I generated data we can use to get the output of our simple network. This is all just random for now, going forward we'll start using normal data. Going through each relevant line:\n",
+ "\n",
+ "`features = torch.randn((1, 5))` creates a tensor with shape `(1, 5)`, one row and five columns, that contains values randomly distributed according to the normal distribution with a mean of zero and standard deviation of one. \n",
+ "\n",
+ "`weights = torch.randn_like(features)` creates another tensor with the same shape as `features`, again containing values from a normal distribution.\n",
+ "\n",
+ "Finally, `bias = torch.randn((1, 1))` creates a single value from a normal distribution.\n",
+ "\n",
+ "PyTorch tensors can be added, multiplied, subtracted, etc, just like Numpy arrays. In general, you'll use PyTorch tensors pretty much the same way you'd use Numpy arrays. They come with some nice benefits though such as GPU acceleration which we'll get to later. For now, use the generated data to calculate the output of this simple single layer network. \n",
+ "> **Exercise**: Calculate the output of the network with input features `features`, weights `weights`, and bias `bias`. Similar to Numpy, PyTorch has a [`torch.sum()`](https://pytorch.org/docs/stable/torch.html#torch.sum) function, as well as a `.sum()` method on tensors, for taking sums. Use the function `activation` defined above as the activation function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[-1.6619]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "## Calculate the output of this network using the weights and bias tensors\n",
+ "sum = torch.matmul(features, weights.view(5, 1)) + bias\n",
+ "print(sum)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can do the multiplication and sum in the same operation using a matrix multiplication. In general, you'll want to use matrix multiplications since they are more efficient and accelerated using modern libraries and high-performance computing on GPUs.\n",
+ "\n",
+ "Here, we want to do a matrix multiplication of the features and the weights. For this we can use [`torch.mm()`](https://pytorch.org/docs/stable/torch.html#torch.mm) or [`torch.matmul()`](https://pytorch.org/docs/stable/torch.html#torch.matmul) which is somewhat more complicated and supports broadcasting. If we try to do it with `features` and `weights` as they are, we'll get an error\n",
+ "\n",
+ "```python\n",
+ ">> torch.mm(features, weights)\n",
+ "\n",
+ "---------------------------------------------------------------------------\n",
+ "RuntimeError Traceback (most recent call last)\n",
+ " in ()\n",
+ "----> 1 torch.mm(features, weights)\n",
+ "\n",
+ "RuntimeError: size mismatch, m1: [1 x 5], m2: [1 x 5] at /Users/soumith/minicondabuild3/conda-bld/pytorch_1524590658547/work/aten/src/TH/generic/THTensorMath.c:2033\n",
+ "```\n",
+ "\n",
+ "As you're building neural networks in any framework, you'll see this often. Really often. What's happening here is our tensors aren't the correct shapes to perform a matrix multiplication. Remember that for matrix multiplications, the number of columns in the first tensor must equal to the number of rows in the second column. Both `features` and `weights` have the same shape, `(1, 5)`. This means we need to change the shape of `weights` to get the matrix multiplication to work.\n",
+ "\n",
+ "**Note:** To see the shape of a tensor called `tensor`, use `tensor.shape`. If you're building neural networks, you'll be using this method often.\n",
+ "\n",
+ "There are a few options here: [`weights.reshape()`](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.reshape), [`weights.resize_()`](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.resize_), and [`weights.view()`](https://pytorch.org/docs/stable/tensors.html#torch.Tensor.view).\n",
+ "\n",
+ "* `weights.reshape(a, b)` will return a new tensor with the same data as `weights` with size `(a, b)` sometimes, and sometimes a clone, as in it copies the data to another part of memory.\n",
+ "* `weights.resize_(a, b)` returns the same tensor with a different shape. However, if the new shape results in fewer elements than the original tensor, some elements will be removed from the tensor (but not from memory). If the new shape results in more elements than the original tensor, new elements will be uninitialized in memory. Here I should note that the underscore at the end of the method denotes that this method is performed **in-place**. Here is a great forum thread to [read more about in-place operations](https://discuss.pytorch.org/t/what-is-in-place-operation/16244) in PyTorch.\n",
+ "* `weights.view(a, b)` will return a new tensor with the same data as `weights` with size `(a, b)`.\n",
+ "\n",
+ "I usually use `.view()`, but any of the three methods will work for this. So, now we can reshape `weights` to have five rows and one column with something like `weights.view(5, 1)`.\n",
+ "\n",
+ "> **Exercise**: Calculate the output of our little network using matrix multiplication."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 0.1595]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "## Calculate the output of this y = activation(sum)\n",
+ "y = activation(sum)\n",
+ "print(y)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Stack them up!\n",
+ "\n",
+ "That's how you can calculate the output for a single neuron. The real power of this algorithm happens when you start stacking these individual units into layers and stacks of layers, into a network of neurons. The output of one layer of neurons becomes the input for the next layer. With multiple input units and output units, we now need to express the weights as a matrix.\n",
+ "\n",
+ "\n",
+ "\n",
+ "The first layer shown on the bottom here are the inputs, understandably called the **input layer**. The middle layer is called the **hidden layer**, and the final layer (on the right) is the **output layer**. We can express this network mathematically with matrices again and use matrix multiplication to get linear combinations for each unit in one operation. For example, the hidden layer ($h_1$ and $h_2$ here) can be calculated \n",
+ "\n",
+ "$$\n",
+ "\\vec{h} = [h_1 \\, h_2] = \n",
+ "\\begin{bmatrix}\n",
+ "x_1 \\, x_2 \\cdots \\, x_n\n",
+ "\\end{bmatrix}\n",
+ "\\cdot \n",
+ "\\begin{bmatrix}\n",
+ " w_{11} & w_{12} \\\\\n",
+ " w_{21} &w_{22} \\\\\n",
+ " \\vdots &\\vdots \\\\\n",
+ " w_{n1} &w_{n2}\n",
+ "\\end{bmatrix}\n",
+ "$$\n",
+ "\n",
+ "The output for this small network is found by treating the hidden layer as inputs for the output unit. The network output is expressed simply\n",
+ "\n",
+ "$$\n",
+ "y = f_2 \\! \\left(\\, f_1 \\! \\left(\\vec{x} \\, \\mathbf{W_1}\\right) \\mathbf{W_2} \\right)\n",
+ "$$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "### Generate some data\n",
+ "torch.manual_seed(7) # Set the random seed so things are predictable\n",
+ "\n",
+ "# Features are 3 random normal variables\n",
+ "features = torch.randn((1, 3))\n",
+ "\n",
+ "# Define the size of each layer in our network\n",
+ "n_input = features.shape[1] # Number of input units, must match number of input features\n",
+ "n_hidden = 2 # Number of hidden units \n",
+ "n_output = 1 # Number of output units\n",
+ "\n",
+ "# Weights for inputs to hidden layer\n",
+ "W1 = torch.randn(n_input, n_hidden)\n",
+ "# Weights for hidden layer to output layer\n",
+ "W2 = torch.randn(n_hidden, n_output)\n",
+ "\n",
+ "# and bias terms for hidden and output layers\n",
+ "B1 = torch.randn((1, n_hidden))\n",
+ "B2 = torch.randn((1, n_output))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "> **Exercise:** Calculate the output for this multi-layer network using the weights `W1` & `W2`, and the biases, `B1` & `B2`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 0.3171]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "## Your solution here\n",
+ "h = torch.mm(features, W1) + B1\n",
+ "h = activation(h)\n",
+ "output = torch.mm(h, W2) + B2\n",
+ "output = activation(output)\n",
+ "print(output)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If you did this correctly, you should see the output `tensor([[ 0.3171]])`.\n",
+ "\n",
+ "The number of hidden units a parameter of the network, often called a **hyperparameter** to differentiate it from the weights and biases parameters. As you'll see later when we discuss training a neural network, the more hidden units a network has, and the more layers, the better able it is to learn from data and make accurate predictions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Numpy to Torch and back\n",
+ "\n",
+ "Special bonus section! PyTorch has a great feature for converting between Numpy arrays and Torch tensors. To create a tensor from a Numpy array, use `torch.from_numpy()`. To convert a tensor to a Numpy array, use the `.numpy()` method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 0.25916044, 0.07974115, 0.13661261],\n",
+ " [ 0.12537927, 0.68318453, 0.24728824],\n",
+ " [ 0.49867652, 0.62760544, 0.84363415],\n",
+ " [ 0.39216351, 0.87075396, 0.0653991 ]])"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "a = np.random.rand(4,3)\n",
+ "a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[ 0.2592, 0.0797, 0.1366],\n",
+ " [ 0.1254, 0.6832, 0.2473],\n",
+ " [ 0.4987, 0.6276, 0.8436],\n",
+ " [ 0.3922, 0.8708, 0.0654]], dtype=torch.float64)"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b = torch.from_numpy(a)\n",
+ "b"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 0.25916044, 0.07974115, 0.13661261],\n",
+ " [ 0.12537927, 0.68318453, 0.24728824],\n",
+ " [ 0.49867652, 0.62760544, 0.84363415],\n",
+ " [ 0.39216351, 0.87075396, 0.0653991 ]])"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b.numpy()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The memory is shared between the Numpy array and Torch tensor, so if you change the values in-place of one object, the other will change as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[ 0.5183, 0.1595, 0.2732],\n",
+ " [ 0.2508, 1.3664, 0.4946],\n",
+ " [ 0.9974, 1.2552, 1.6873],\n",
+ " [ 0.7843, 1.7415, 0.1308]], dtype=torch.float64)"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Multiply PyTorch Tensor by 2, in place\n",
+ "b.mul_(2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 0.51832089, 0.15948231, 0.27322523],\n",
+ " [ 0.25075854, 1.36636907, 0.49457648],\n",
+ " [ 0.99735305, 1.25521088, 1.68726831],\n",
+ " [ 0.78432703, 1.74150792, 0.1307982 ]])"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Numpy array matches new values from Tensor\n",
+ "a"
+ ]
+ },
+ {
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb
new file mode 100644
index 0000000..7754816
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb
@@ -0,0 +1,870 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Neural networks with PyTorch\n",
+ "\n",
+ "Deep learning networks tend to be massive with dozens or hundreds of layers, that's where the term \"deep\" comes from. You can build one of these deep networks using only weight matrices as we did in the previous notebook, but in general it's very cumbersome and difficult to implement. PyTorch has a nice module `nn` that provides a nice way to efficiently build large neural networks."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Import necessary packages\n",
+ "\n",
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "\n",
+ "import helper\n",
+ "\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Now we're going to build a larger network that can solve a (formerly) difficult problem, identifying text in an image. Here we'll use the MNIST dataset which consists of greyscale handwritten digits. Each image is 28x28 pixels, you can see a sample below\n",
+ "\n",
+ "\n",
+ "\n",
+ "Our goal is to build a neural network that can take one of these images and predict the digit in the image.\n",
+ "\n",
+ "First up, we need to get our dataset. This is provided through the `torchvision` package. The code below will download the MNIST dataset, then create training and test datasets for us. Don't worry too much about the details here, you'll learn more about this later."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
+ "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
+ "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
+ "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
+ "Processing...\n",
+ "Done!\n"
+ ]
+ }
+ ],
+ "source": [
+ "### Run this cell\n",
+ "\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Define a transform to normalize the data\n",
+ "transform = transforms.Compose([transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5,), (0.5,)),\n",
+ " ])\n",
+ "\n",
+ "# Download and load the training data\n",
+ "trainset = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=True, transform=transform)\n",
+ "trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We have the training data loaded into `trainloader` and we make that an iterator with `iter(trainloader)`. Later, we'll use this to loop through the dataset for training, like\n",
+ "\n",
+ "```python\n",
+ "for image, label in trainloader:\n",
+ " ## do things with images and labels\n",
+ "```\n",
+ "\n",
+ "You'll notice I created the `trainloader` with a batch size of 64, and `shuffle=True`. The batch size is the number of images we get in one iteration from the data loader and pass through our network, often called a *batch*. And `shuffle=True` tells it to shuffle the dataset every time we start going through the data loader again. But here I'm just grabbing the first batch so we can check out the data. We can see below that `images` is just a tensor with size `(64, 1, 28, 28)`. So, 64 images per batch, 1 color channel, and 28x28 images."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "torch.Size([64, 1, 28, 28])\n",
+ "torch.Size([64])\n"
+ ]
+ }
+ ],
+ "source": [
+ "dataiter = iter(trainloader)\n",
+ "images, labels = dataiter.next()\n",
+ "print(type(images))\n",
+ "print(images.shape)\n",
+ "print(labels.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This is what one of the images looks like. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 250,
+ "width": 253
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.imshow(images[1].numpy().squeeze(), cmap='Greys_r');"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "First, let's try to build a simple network for this dataset using weight matrices and matrix multiplications. Then, we'll see how to do it using PyTorch's `nn` module which provides a much more convenient and powerful method for defining network architectures.\n",
+ "\n",
+ "The networks you've seen so far are called *fully-connected* or *dense* networks. Each unit in one layer is connected to each unit in the next layer. In fully-connected networks, the input to each layer must be a one-dimensional vector (which can be stacked into a 2D tensor as a batch of multiple examples). However, our images are 28x28 2D tensors, so we need to convert them into 1D vectors. Thinking about sizes, we need to convert the batch of images with shape `(64, 1, 28, 28)` to a have a shape of `(64, 784)`, 784 is 28 times 28. This is typically called *flattening*, we flattened the 2D images into 1D vectors.\n",
+ "\n",
+ "Previously you built a network with one output unit. Here we need 10 output units, one for each digit. We want our network to predict the digit shown in an image, so what we'll do is calculate probabilities that the image is of any one digit or class. This ends up being a discrete probability distribution over the classes (digits) that tells us the most likely class for the image. That means we need 10 output units for the 10 classes (digits). We'll see how to convert the network output into a probability distribution next.\n",
+ "\n",
+ "> **Exercise:** Flatten the batch of images `images`. Then build a multi-layer network with 784 input units, 256 hidden units, and 10 output units using random tensors for the weights and biases. For now, use a sigmoid activation for the hidden layer. Leave the output layer without an activation, we'll add one that gives us a probability distribution next."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "## Your solution\n",
+ "def activation(x):\n",
+ " return 1 / (1 + torch.exp(-x))\n",
+ "\n",
+ "# Flatten images\n",
+ "\n",
+ "inputs = images.view(images.shape[0], -1)\n",
+ "\n",
+ "# Create parameters\n",
+ "w1 = torch.randn(784, 256)\n",
+ "b1 = torch.randn(256)\n",
+ "\n",
+ "w2 = torch.randn(256, 10)\n",
+ "b2 = torch.randn(10)\n",
+ "\n",
+ "h = activation(torch.mm(inputs, w1) + b1)\n",
+ "\n",
+ "out = torch.mm(h, w2) + b2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we have 10 outputs for our network. We want to pass in an image to our network and get out a probability distribution over the classes that tells us the likely class(es) the image belongs to. Something that looks like this:\n",
+ "\n",
+ "\n",
+ "Here we see that the probability for each class is roughly the same. This is representing an untrained network, it hasn't seen any data yet so it just returns a uniform distribution with equal probabilities for each class.\n",
+ "\n",
+ "To calculate this probability distribution, we often use the [**softmax** function](https://en.wikipedia.org/wiki/Softmax_function). Mathematically this looks like\n",
+ "\n",
+ "$$\n",
+ "\\Large \\sigma(x_i) = \\cfrac{e^{x_i}}{\\sum_k^K{e^{x_k}}}\n",
+ "$$\n",
+ "\n",
+ "What this does is squish each input $x_i$ between 0 and 1 and normalizes the values to give you a proper probability distribution where the probabilites sum up to one.\n",
+ "\n",
+ "> **Exercise:** Implement a function `softmax` that performs the softmax calculation and returns probability distributions for each example in the batch. Note that you'll need to pay attention to the shapes when doing this. If you have a tensor `a` with shape `(64, 10)` and a tensor `b` with shape `(64,)`, doing `a/b` will give you an error because PyTorch will try to do the division across the columns (called broadcasting) but you'll get a size mismatch. The way to think about this is for each of the 64 examples, you only want to divide by one value, the sum in the denominator. So you need `b` to have a shape of `(64, 1)`. This way PyTorch will divide the 10 values in each row of `a` by the one value in each row of `b`. Pay attention to how you take the sum as well. You'll need to define the `dim` keyword in `torch.sum`. Setting `dim=0` takes the sum across the rows while `dim=1` takes the sum across the columns."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "torch.Size([64, 10])\n",
+ "tensor([ 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000])\n"
+ ]
+ }
+ ],
+ "source": [
+ "def softmax(x):\n",
+ " ## TODO: Implement the softmax function here\n",
+ " return torch.exp(x) / torch.sum(torch.exp(x), dim=1).view(-1, 1)\n",
+ "\n",
+ "# Here, out should be the output of the network in the previous excercise with shape (64,10)\n",
+ "probabilities = softmax(out)\n",
+ "\n",
+ "# Does it have the right shape? Should be (64, 10)\n",
+ "print(probabilities.shape)\n",
+ "# Does it sum to 1?\n",
+ "print(probabilities.sum(dim=1))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Building networks with PyTorch\n",
+ "\n",
+ "PyTorch provides a module `nn` that makes building networks much simpler. Here I'll show you how to build the same one as above with 784 inputs, 256 hidden units, 10 output units and a softmax output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from torch import nn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Network(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " \n",
+ " # Inputs to hidden layer linear transformation\n",
+ " self.hidden = nn.Linear(784, 256)\n",
+ " # Output layer, 10 units - one for each digit\n",
+ " self.output = nn.Linear(256, 10)\n",
+ " \n",
+ " # Define sigmoid activation and softmax output \n",
+ " self.sigmoid = nn.Sigmoid()\n",
+ " self.softmax = nn.Softmax(dim=1)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # Pass the input tensor through each of our operations\n",
+ " x = self.hidden(x)\n",
+ " x = self.sigmoid(x)\n",
+ " x = self.output(x)\n",
+ " x = self.softmax(x)\n",
+ " \n",
+ " return x"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's go through this bit by bit.\n",
+ "\n",
+ "```python\n",
+ "class Network(nn.Module):\n",
+ "```\n",
+ "\n",
+ "Here we're inheriting from `nn.Module`. Combined with `super().__init__()` this creates a class that tracks the architecture and provides a lot of useful methods and attributes. It is mandatory to inherit from `nn.Module` when you're creating a class for your network. The name of the class itself can be anything.\n",
+ "\n",
+ "```python\n",
+ "self.hidden = nn.Linear(784, 256)\n",
+ "```\n",
+ "\n",
+ "This line creates a module for a linear transformation, $x\\mathbf{W} + b$, with 784 inputs and 256 outputs and assigns it to `self.hidden`. The module automatically creates the weight and bias tensors which we'll use in the `forward` method. You can access the weight and bias tensors once the network (`net`) is created with `net.hidden.weight` and `net.hidden.bias`.\n",
+ "\n",
+ "```python\n",
+ "self.output = nn.Linear(256, 10)\n",
+ "```\n",
+ "\n",
+ "Similarly, this creates another linear transformation with 256 inputs and 10 outputs.\n",
+ "\n",
+ "```python\n",
+ "self.sigmoid = nn.Sigmoid()\n",
+ "self.softmax = nn.Softmax(dim=1)\n",
+ "```\n",
+ "\n",
+ "Here I defined operations for the sigmoid activation and softmax output. Setting `dim=1` in `nn.Softmax(dim=1)` calculates softmax across the columns.\n",
+ "\n",
+ "```python\n",
+ "def forward(self, x):\n",
+ "```\n",
+ "\n",
+ "PyTorch networks created with `nn.Module` must have a `forward` method defined. It takes in a tensor `x` and passes it through the operations you defined in the `__init__` method.\n",
+ "\n",
+ "```python\n",
+ "x = self.hidden(x)\n",
+ "x = self.sigmoid(x)\n",
+ "x = self.output(x)\n",
+ "x = self.softmax(x)\n",
+ "```\n",
+ "\n",
+ "Here the input tensor `x` is passed through each operation a reassigned to `x`. We can see that the input tensor goes through the hidden layer, then a sigmoid function, then the output layer, and finally the softmax function. It doesn't matter what you name the variables here, as long as the inputs and outputs of the operations match the network architecture you want to build. The order in which you define things in the `__init__` method doesn't matter, but you'll need to sequence the operations correctly in the `forward` method.\n",
+ "\n",
+ "Now we can create a `Network` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Network(\n",
+ " (hidden): Linear(in_features=784, out_features=256, bias=True)\n",
+ " (output): Linear(in_features=256, out_features=10, bias=True)\n",
+ " (sigmoid): Sigmoid()\n",
+ " (softmax): Softmax()\n",
+ ")"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Create the network and look at it's text representation\n",
+ "model = Network()\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can define the network somewhat more concisely and clearly using the `torch.nn.functional` module. This is the most common way you'll see networks defined as many operations are simple element-wise functions. We normally import this module as `F`, `import torch.nn.functional as F`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch.nn.functional as F\n",
+ "\n",
+ "class Network(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " # Inputs to hidden layer linear transformation\n",
+ " self.hidden = nn.Linear(784, 256)\n",
+ " # Output layer, 10 units - one for each digit\n",
+ " self.output = nn.Linear(256, 10)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # Hidden layer with sigmoid activation\n",
+ " x = F.sigmoid(self.hidden(x))\n",
+ " # Output layer with softmax activation\n",
+ " x = F.softmax(self.output(x), dim=1)\n",
+ " \n",
+ " return x"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Activation functions\n",
+ "\n",
+ "So far we've only been looking at the softmax activation, but in general any function can be used as an activation function. The only requirement is that for a network to approximate a non-linear function, the activation functions must be non-linear. Here are a few more examples of common activation functions: Tanh (hyperbolic tangent), and ReLU (rectified linear unit).\n",
+ "\n",
+ "\n",
+ "\n",
+ "In practice, the ReLU function is used almost exclusively as the activation function for hidden layers."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Your Turn to Build a Network\n",
+ "\n",
+ "\n",
+ "\n",
+ "> **Exercise:** Create a network with 784 input units, a hidden layer with 128 units and a ReLU activation, then a hidden layer with 64 units and a ReLU activation, and finally an output layer with a softmax activation as shown above. You can use a ReLU activation with the `nn.ReLU` module or `F.relu` function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Network(\n",
+ " (l1): Linear(in_features=784, out_features=128, bias=True)\n",
+ " (l2): Linear(in_features=128, out_features=64, bias=True)\n",
+ " (l3): Linear(in_features=64, out_features=10, bias=True)\n",
+ ")"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "## Your solution here\n",
+ "\n",
+ "class Network(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " # Define the layers 128, 64, 10 units each\n",
+ " self.l1 = nn.Linear(784, 128)\n",
+ " self.l2 = nn.Linear(128, 64)\n",
+ " # Define output layer\n",
+ " self.l3 = nn.Linear(64, 10)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " \"\"\"Forward pass through the network - reuturns the output\"\"\"\n",
+ " x = self.l1(x)\n",
+ " x = F.relu(x)\n",
+ " \n",
+ " x = self.l2(x)\n",
+ " x = F.relu(x)\n",
+ " \n",
+ " x = self.l3(x)\n",
+ " x = F.softmax(x, dim=1)\n",
+ " \n",
+ " return x\n",
+ "\n",
+ "model=Network()\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Initializing weights and biases\n",
+ "\n",
+ "The weights and such are automatically initialized for you, but it's possible to customize how they are initialized. The weights and biases are tensors attached to the layer you defined, you can get them with `model.fc1.weight` for instance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Parameter containing:\n",
+ "tensor([[-1.0776e-02, 2.0526e-02, -1.5042e-02, ..., -4.7536e-03,\n",
+ " 2.5714e-03, -5.5181e-03],\n",
+ " [-1.8762e-02, -2.5858e-02, -2.6485e-02, ..., -1.0233e-02,\n",
+ " -2.2680e-02, -5.5377e-04],\n",
+ " [-1.3932e-02, 6.4527e-03, -2.6832e-03, ..., 2.3186e-02,\n",
+ " 2.8184e-02, -5.7248e-04],\n",
+ " ...,\n",
+ " [ 1.4060e-02, 3.0088e-02, -2.8885e-03, ..., 2.5048e-02,\n",
+ " -1.9844e-02, 6.5543e-03],\n",
+ " [ 1.5551e-02, 8.4835e-03, 1.5654e-04, ..., -1.5493e-02,\n",
+ " -4.2152e-03, -2.5316e-02],\n",
+ " [ 1.2114e-03, -1.4411e-02, 1.9116e-02, ..., 3.1978e-02,\n",
+ " 1.9531e-02, -3.2406e-02]])\n",
+ "Parameter containing:\n",
+ "tensor(1.00000e-02 *\n",
+ " [-2.7470, 2.9781, 2.5320, -2.3808, 3.0487, -0.7365, -2.4079,\n",
+ " 0.4414, -1.7073, 1.8509, 3.3353, -0.6008, -3.2928, 3.3918,\n",
+ " 2.9831, 0.0983, -1.1983, -2.0790, 0.9813, -0.6745, -0.3347,\n",
+ " -0.8737, -2.7929, 1.2551, 0.2288, -2.4784, 0.0190, 1.2828,\n",
+ " -0.6021, 2.4832, 3.4782, -0.3269, -1.7032, -3.1000, -2.4096,\n",
+ " -1.1523, -3.1894, 3.4164, -3.0275, -2.3891, -0.0275, 1.7851,\n",
+ " 3.1205, 1.2810, 1.0525, -0.6538, -1.6390, -2.4172, 2.1895,\n",
+ " -1.8027, -0.4446, -1.5385, 2.0806, -1.9547, -0.4899, -1.0428,\n",
+ " 3.3237, 1.0272, 1.2687, 0.9785, -0.6819, -1.0355, -3.1642,\n",
+ " 0.9449, -0.3841, 2.8396, 0.5092, 2.9105, -1.7338, -2.2073,\n",
+ " 1.2315, 1.6605, 0.9994, -0.9812, -1.5683, -0.1603, -0.3632,\n",
+ " 0.3852, -1.0125, 0.2518, 0.2360, 3.5688, -0.3973, 0.8222,\n",
+ " -0.1480, 0.7442, 2.6121, -2.9418, 1.2141, 0.0198, -0.6789,\n",
+ " -0.8365, -0.4946, -0.7336, -0.1345, 1.7144, -1.2053, 1.8478,\n",
+ " -2.6136, 3.3724, -0.7037, -2.8251, -3.3915, 1.9541, 1.3929,\n",
+ " 0.4494, -1.4477, -3.0928, 1.5461, 2.9698, -1.2177, 3.4206,\n",
+ " -0.8522, -0.1440, 0.8285, 0.1339, 0.4546, 2.1396, 1.3242,\n",
+ " 0.1970, 1.6910, 1.9873, 2.1056, -1.9118, 0.0454, -0.4995,\n",
+ " 3.3401, 2.1109])\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(model.l1.weight)\n",
+ "print(model.l1.bias)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For custom initialization, we want to modify these tensors in place. These are actually autograd *Variables*, so we need to get back the actual tensors with `model.fc1.weight.data`. Once we have the tensors, we can fill them with zeros (for biases) or random normal values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0.])"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Set biases to all zeros\n",
+ "model.l1.bias.data.fill_(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[-2.3535e-03, -4.0847e-03, 6.6107e-03, ..., 1.3488e-02,\n",
+ " -3.0676e-03, 4.7938e-03],\n",
+ " [ 2.1113e-02, -1.3056e-02, -1.5310e-02, ..., 1.2427e-03,\n",
+ " 2.0526e-02, -3.7705e-03],\n",
+ " [ 1.2847e-02, -3.6961e-03, 1.8160e-02, ..., -5.9606e-03,\n",
+ " -1.5045e-02, -9.3461e-03],\n",
+ " ...,\n",
+ " [-7.3355e-03, 3.1985e-03, 1.9387e-03, ..., -1.1342e-02,\n",
+ " 3.1593e-04, -2.1606e-03],\n",
+ " [-3.4460e-03, 1.0747e-03, 1.1796e-02, ..., 3.0916e-03,\n",
+ " -1.3553e-02, -6.0074e-03],\n",
+ " [-3.2343e-03, -9.9594e-03, 9.7654e-03, ..., 6.7241e-03,\n",
+ " -4.3026e-03, 5.2910e-03]])"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# sample from random normal with standard dev = 0.01\n",
+ "model.l1.weight.data.normal_(std=0.01)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Forward pass\n",
+ "\n",
+ "Now that we have a network, let's see what happens when we pass in an image."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 224,
+ "width": 423
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Grab some data \n",
+ "dataiter = iter(trainloader)\n",
+ "images, labels = dataiter.next()\n",
+ "\n",
+ "# Resize images into a 1D vector, new shape is (batch size, color channels, image pixels) \n",
+ "images.resize_(64, 1, 784)\n",
+ "# or images.resize_(images.shape[0], 1, 784) to automatically get batch size\n",
+ "\n",
+ "# Forward pass through the network\n",
+ "img_idx = 0\n",
+ "ps = model.forward(images[img_idx,:])\n",
+ "\n",
+ "img = images[img_idx]\n",
+ "helper.view_classify(img.view(1, 28, 28), ps)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "As you can see above, our network has basically no idea what this digit is. It's because we haven't trained it yet, all the weights are random!\n",
+ "\n",
+ "### Using `nn.Sequential`\n",
+ "\n",
+ "PyTorch provides a convenient way to build networks like this where a tensor is passed sequentially through operations, `nn.Sequential` ([documentation](https://pytorch.org/docs/master/nn.html#torch.nn.Sequential)). Using this to build the equivalent network:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Sequential(\n",
+ " (0): Linear(in_features=784, out_features=128, bias=True)\n",
+ " (1): ReLU()\n",
+ " (2): Linear(in_features=128, out_features=64, bias=True)\n",
+ " (3): ReLU()\n",
+ " (4): Linear(in_features=64, out_features=10, bias=True)\n",
+ " (5): Softmax()\n",
+ ")\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 224,
+ "width": 423
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Hyperparameters for our network\n",
+ "input_size = 784\n",
+ "hidden_sizes = [128, 64]\n",
+ "output_size = 10\n",
+ "\n",
+ "# Build a feed-forward network\n",
+ "model = nn.Sequential(nn.Linear(input_size, hidden_sizes[0]),\n",
+ " nn.ReLU(),\n",
+ " nn.Linear(hidden_sizes[0], hidden_sizes[1]),\n",
+ " nn.ReLU(),\n",
+ " nn.Linear(hidden_sizes[1], output_size),\n",
+ " nn.Softmax(dim=1))\n",
+ "print(model)\n",
+ "\n",
+ "# Forward pass through the network and display output\n",
+ "images, labels = next(iter(trainloader))\n",
+ "images.resize_(images.shape[0], 1, 784)\n",
+ "ps = model.forward(images[0,:])\n",
+ "helper.view_classify(images[0].view(1, 28, 28), ps)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Here our model is the same as before: 784 input units, a hidden layer with 128 units, ReLU activation, 64 unit hidden layer, another ReLU, then the output layer with 10 units, and the softmax output.\n",
+ "\n",
+ "The operations are availble by passing in the appropriate index. For example, if you want to get first Linear operation and look at the weights, you'd use `model[0]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Linear(in_features=784, out_features=128, bias=True)\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "Parameter containing:\n",
+ "tensor([[-2.4938e-02, -7.7938e-03, 6.8920e-02, ..., 4.9189e-02,\n",
+ " 7.5370e-02, 7.8373e-02],\n",
+ " [-8.0918e-02, -3.0586e-02, -4.4575e-02, ..., 3.4322e-02,\n",
+ " 9.7493e-04, 3.5337e-02],\n",
+ " [-3.6158e-03, -1.0852e-02, 2.2992e-02, ..., 7.2592e-02,\n",
+ " -8.1835e-02, 3.0893e-02],\n",
+ " ...,\n",
+ " [-7.4640e-02, 4.8931e-02, 3.2685e-02, ..., -3.6627e-02,\n",
+ " -5.1732e-02, 8.4485e-02],\n",
+ " [-1.1577e-02, 2.1981e-02, -3.5689e-02, ..., 7.4438e-02,\n",
+ " -5.9650e-02, 5.7569e-02],\n",
+ " [ 7.3337e-02, 3.8470e-02, -3.5789e-02, ..., 5.3540e-02,\n",
+ " 1.4137e-02, 5.9897e-02]])"
+ ]
+ },
+ "execution_count": 39,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "print(model[0])\n",
+ "model[2].weight"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can also pass in an `OrderedDict` to name the individual layers and operations, instead of using incremental integers. Note that dictionary keys must be unique, so _each operation must have a different name_."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 40,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Sequential(\n",
+ " (fc1): Linear(in_features=784, out_features=128, bias=True)\n",
+ " (relu1): ReLU()\n",
+ " (fc2): Linear(in_features=128, out_features=64, bias=True)\n",
+ " (relu2): ReLU()\n",
+ " (output): Linear(in_features=64, out_features=10, bias=True)\n",
+ " (softmax): Softmax()\n",
+ ")"
+ ]
+ },
+ "execution_count": 40,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from collections import OrderedDict\n",
+ "model = nn.Sequential(OrderedDict([\n",
+ " ('fc1', nn.Linear(input_size, hidden_sizes[0])),\n",
+ " ('relu1', nn.ReLU()),\n",
+ " ('fc2', nn.Linear(hidden_sizes[0], hidden_sizes[1])),\n",
+ " ('relu2', nn.ReLU()),\n",
+ " ('output', nn.Linear(hidden_sizes[1], output_size)),\n",
+ " ('softmax', nn.Softmax(dim=1))]))\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now you can access layers either by integer or the name"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 41,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Linear(in_features=784, out_features=128, bias=True)\n",
+ "Linear(in_features=784, out_features=128, bias=True)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(model[0])\n",
+ "print(model.fc1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In the next notebook, we'll see how we can train a neural network to accuractly predict the numbers appearing in the MNIST images."
+ ]
+ }
+ ],
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 3 - Training Neural Networks (Exercises).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 3 - Training Neural Networks (Exercises).ipynb
new file mode 100644
index 0000000..33e10dc
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 3 - Training Neural Networks (Exercises).ipynb
@@ -0,0 +1,890 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Training Neural Networks\n",
+ "\n",
+ "The network we built in the previous part isn't so smart, it doesn't know anything about our handwritten digits. Neural networks with non-linear activations work like universal function approximators. There is some function that maps your input to the output. For example, images of handwritten digits to class probabilities. The power of neural networks is that we can train them to approximate this function, and basically any function given enough data and compute time.\n",
+ "\n",
+ "\n",
+ "\n",
+ "At first the network is naive, it doesn't know the function mapping the inputs to the outputs. We train the network by showing it examples of real data, then adjusting the network parameters such that it approximates this function.\n",
+ "\n",
+ "To find these parameters, we need to know how poorly the network is predicting the real outputs. For this we calculate a **loss function** (also called the cost), a measure of our prediction error. For example, the mean squared loss is often used in regression and binary classification problems\n",
+ "\n",
+ "$$\n",
+ "\\large \\ell = \\frac{1}{2n}\\sum_i^n{\\left(y_i - \\hat{y}_i\\right)^2}\n",
+ "$$\n",
+ "\n",
+ "where $n$ is the number of training examples, $y_i$ are the true labels, and $\\hat{y}_i$ are the predicted labels.\n",
+ "\n",
+ "By minimizing this loss with respect to the network parameters, we can find configurations where the loss is at a minimum and the network is able to predict the correct labels with high accuracy. We find this minimum using a process called **gradient descent**. The gradient is the slope of the loss function and points in the direction of fastest change. To get to the minimum in the least amount of time, we then want to follow the gradient (downwards). You can think of this like descending a mountain by following the steepest slope to the base.\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Backpropagation\n",
+ "\n",
+ "For single layer networks, gradient descent is straightforward to implement. However, it's more complicated for deeper, multilayer neural networks like the one we've built. Complicated enough that it took about 30 years before researchers figured out how to train multilayer networks.\n",
+ "\n",
+ "Training multilayer networks is done through **backpropagation** which is really just an application of the chain rule from calculus. It's easiest to understand if we convert a two layer network into a graph representation.\n",
+ "\n",
+ "\n",
+ "\n",
+ "In the forward pass through the network, our data and operations go from bottom to top here. We pass the input $x$ through a linear transformation $L_1$ with weights $W_1$ and biases $b_1$. The output then goes through the sigmoid operation $S$ and another linear transformation $L_2$. Finally we calculate the loss $\\ell$. We use the loss as a measure of how bad the network's predictions are. The goal then is to adjust the weights and biases to minimize the loss.\n",
+ "\n",
+ "To train the weights with gradient descent, we propagate the gradient of the loss backwards through the network. Each operation has some gradient between the inputs and outputs. As we send the gradients backwards, we multiply the incoming gradient with the gradient for the operation. Mathematically, this is really just calculating the gradient of the loss with respect to the weights using the chain rule.\n",
+ "\n",
+ "$$\n",
+ "\\large \\frac{\\partial \\ell}{\\partial W_1} = \\frac{\\partial L_1}{\\partial W_1} \\frac{\\partial S}{\\partial L_1} \\frac{\\partial L_2}{\\partial S} \\frac{\\partial \\ell}{\\partial L_2}\n",
+ "$$\n",
+ "\n",
+ "**Note:** I'm glossing over a few details here that require some knowledge of vector calculus, but they aren't necessary to understand what's going on.\n",
+ "\n",
+ "We update our weights using this gradient with some learning rate $\\alpha$. \n",
+ "\n",
+ "$$\n",
+ "\\large W^\\prime_1 = W_1 - \\alpha \\frac{\\partial \\ell}{\\partial W_1}\n",
+ "$$\n",
+ "\n",
+ "The learning rate $\\alpha$ is set such that the weight update steps are small enough that the iterative method settles in a minimum."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Losses in PyTorch\n",
+ "\n",
+ "Let's start by seeing how we calculate the loss with PyTorch. Through the `nn` module, PyTorch provides losses such as the cross-entropy loss (`nn.CrossEntropyLoss`). You'll usually see the loss assigned to `criterion`. As noted in the last part, with a classification problem such as MNIST, we're using the softmax function to predict class probabilities. With a softmax output, you want to use cross-entropy as the loss. To actually calculate the loss, you first define the criterion then pass in the output of your network and the correct labels.\n",
+ "\n",
+ "Something really important to note here. Looking at [the documentation for `nn.CrossEntropyLoss`](https://pytorch.org/docs/stable/nn.html#torch.nn.CrossEntropyLoss),\n",
+ "\n",
+ "> This criterion combines `nn.LogSoftmax()` and `nn.NLLLoss()` in one single class.\n",
+ ">\n",
+ "> The input is expected to contain scores for each class.\n",
+ "\n",
+ "This means we need to pass in the raw output of our network into the loss, not the output of the softmax function. This raw output is usually called the *logits* or *scores*. We use the logits because softmax gives you probabilities which will often be very close to zero or one but floating-point numbers can't accurately represent values near zero or one ([read more here](https://docs.python.org/3/tutorial/floatingpoint.html)). It's usually best to avoid doing calculations with probabilities, typically we use log-probabilities."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "from torch import nn\n",
+ "import torch.nn.functional as F\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Define a transform to normalize the data\n",
+ "transform = transforms.Compose([transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n",
+ " ])\n",
+ "# Download and load the training data\n",
+ "trainset = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=True, transform=transform)\n",
+ "trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Note\n",
+ "If you haven't seen `nn.Sequential` yet, please finish the end of the Part 2 notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor(2.3037)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Build a feed-forward network\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",
+ "\n",
+ "# Define the loss\n",
+ "criterion = nn.CrossEntropyLoss()\n",
+ "\n",
+ "# Get our data\n",
+ "images, labels = next(iter(trainloader))\n",
+ "# Flatten images\n",
+ "images = images.view(images.shape[0], -1)\n",
+ "\n",
+ "# Forward pass, get our logits\n",
+ "logits = model(images)\n",
+ "# Calculate the loss with the logits and the labels\n",
+ "loss = criterion(logits, labels)\n",
+ "\n",
+ "print(loss)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In my experience it's more convenient to build the model with a log-softmax output using `nn.LogSoftmax` or `F.log_softmax` ([documentation](https://pytorch.org/docs/stable/nn.html#torch.nn.LogSoftmax)). Then you can get the actual probabilities by taking the exponential `torch.exp(output)`. With a log-softmax output, you want to use the negative log likelihood loss, `nn.NLLLoss` ([documentation](https://pytorch.org/docs/stable/nn.html#torch.nn.NLLLoss)).\n",
+ "\n",
+ ">**Exercise:** Build a model that returns the log-softmax as the output and calculate the loss using the negative log likelihood loss. Note that for `nn.LogSoftmax` and `F.log_softmax` you'll need to set the `dim` keyword argument appropriately. `dim=0` calculates softmax across the rows, so each column sums to 1, while `dim=1` calculates across the columns so each row sums to 1. Think about what you want the output to be and choose `dim` appropriately."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor(2.3134)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# TODO: Build a feed-forward network\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))\n",
+ "\n",
+ "# TODO: Define the loss\n",
+ "criterion = nn.NLLLoss()\n",
+ "\n",
+ "### Run this to check your work\n",
+ "# Get our data\n",
+ "images, labels = next(iter(trainloader))\n",
+ "# Flatten images\n",
+ "images = images.view(images.shape[0], -1)\n",
+ "\n",
+ "# Forward pass, get our logits\n",
+ "logits = model(images)\n",
+ "# Calculate the loss with the logits and the labels\n",
+ "loss = criterion(logits, labels)\n",
+ "\n",
+ "print(loss)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Autograd\n",
+ "\n",
+ "Now that we know how to calculate a loss, how do we use it to perform backpropagation? Torch provides a module, `autograd`, for automatically calculating the gradients of tensors. We can use it to calculate the gradients of all our parameters with respect to the loss. Autograd works by keeping track of operations performed on tensors, then going backwards through those operations, calculating gradients along the way. To make sure PyTorch keeps track of operations on a tensor and calculates the gradients, you need to set `requires_grad = True` on a tensor. You can do this at creation with the `requires_grad` keyword, or at any time with `x.requires_grad_(True)`.\n",
+ "\n",
+ "You can turn off gradients for a block of code with the `torch.no_grad()` content:\n",
+ "```python\n",
+ "x = torch.zeros(1, requires_grad=True)\n",
+ ">>> with torch.no_grad():\n",
+ "... y = x * 2\n",
+ ">>> y.requires_grad\n",
+ "False\n",
+ "```\n",
+ "\n",
+ "Also, you can turn on or off gradients altogether with `torch.set_grad_enabled(True|False)`.\n",
+ "\n",
+ "The gradients are computed with respect to some variable `z` with `z.backward()`. This does a backward pass through the operations that created `z`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[-0.1234, 1.2443],\n",
+ " [-1.2560, -0.1746]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "x = torch.randn(2,2, requires_grad=True)\n",
+ "print(x)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 0.0152, 1.5482],\n",
+ " [ 1.5776, 0.0305]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "y = x**2\n",
+ "print(y)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Below we can see the operation that created `y`, a power operation `PowBackward0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "## grad_fn shows the function that generated this variable\n",
+ "print(y.grad_fn)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The autgrad module keeps track of these operations and knows how to calculate the gradient for each one. In this way, it's able to calculate the gradients for a chain of operations, with respect to any one tensor. Let's reduce the tensor `y` to a scalar value, the mean."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor(0.7929)\n"
+ ]
+ }
+ ],
+ "source": [
+ "z = y.mean()\n",
+ "print(z)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can check the gradients for `x` and `y` but they are empty currently."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "None\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(x.grad)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "To calculate the gradients, you need to run the `.backward` method on a Variable, `z` for example. This will calculate the gradient for `z` with respect to `x`\n",
+ "\n",
+ "$$\n",
+ "\\frac{\\partial z}{\\partial x} = \\frac{\\partial}{\\partial x}\\left[\\frac{1}{n}\\sum_i^n x_i^2\\right] = \\frac{x}{2}\n",
+ "$$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[-0.0617, 0.6221],\n",
+ " [-0.6280, -0.0873]])\n",
+ "tensor([[-0.0617, 0.6221],\n",
+ " [-0.6280, -0.0873]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "z.backward()\n",
+ "print(x.grad)\n",
+ "print(x/2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "These gradients calculations are particularly useful for neural networks. For training we need the gradients of the weights with respect to the cost. With PyTorch, we run data forward through the network to calculate the loss, then, go backwards to calculate the gradients with respect to the loss. Once we have the gradients we can make a gradient descent step. "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Loss and Autograd together\n",
+ "\n",
+ "When we create a network with PyTorch, all of the parameters are initialized with `requires_grad = True`. This means that when we calculate the loss and call `loss.backward()`, the gradients for the parameters are calculated. These gradients are used to update the weights with gradient descent. Below you can see an example of calculating the gradients using a backwards pass."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 21,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Build a feed-forward network\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))\n",
+ "\n",
+ "criterion = nn.NLLLoss()\n",
+ "images, labels = next(iter(trainloader))\n",
+ "images = images.view(images.shape[0], -1)\n",
+ "\n",
+ "logits = model(images)\n",
+ "loss = criterion(logits, labels)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Before backward pass: \n",
+ " None\n",
+ "After backward pass: \n",
+ " tensor(1.00000e-02 *\n",
+ " [[ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n",
+ " [ 0.1559, 0.1559, 0.1559, ..., 0.1559, 0.1559, 0.1559],\n",
+ " [-0.2130, -0.2130, -0.2130, ..., -0.2130, -0.2130, -0.2130],\n",
+ " ...,\n",
+ " [ 0.0225, 0.0225, 0.0225, ..., 0.0225, 0.0225, 0.0225],\n",
+ " [ 0.0050, 0.0050, 0.0050, ..., 0.0050, 0.0050, 0.0050],\n",
+ " [ 0.1201, 0.1201, 0.1201, ..., 0.1201, 0.1201, 0.1201]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "print('Before backward pass: \\n', model[0].weight.grad)\n",
+ "\n",
+ "loss.backward()\n",
+ "\n",
+ "print('After backward pass: \\n', model[0].weight.grad)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Training the network!\n",
+ "\n",
+ "There's one last piece we need to start training, an optimizer that we'll use to update the weights with the gradients. We get these from PyTorch's [`optim` package](https://pytorch.org/docs/stable/optim.html). For example we can use stochastic gradient descent with `optim.SGD`. You can see how to define an optimizer below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from torch import optim\n",
+ "\n",
+ "# Optimizers require the parameters to optimize and a learning rate\n",
+ "optimizer = optim.SGD(model.parameters(), lr=0.01)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we know how to use all the individual parts so it's time to see how they work together. Let's consider just one learning step before looping through all the data. The general process with PyTorch:\n",
+ "\n",
+ "* Make a forward pass through the network \n",
+ "* Use the network output 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",
+ "Below I'll go through one training step and print out the weights and gradients so you can see how it changes. Note that I have a line of code `optimizer.zero_grad()`. When you do multiple backwards passes with the same parameters, the gradients are accumulated. This means that you need to zero the gradients on each training pass or you'll retain gradients from previous training batches."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Initial weights - Parameter containing:\n",
+ "tensor(1.00000e-02 *\n",
+ " [[-2.7038, 1.9887, 3.2999, ..., 0.8496, -2.6579, -0.8653],\n",
+ " [ 2.2119, 3.2675, 1.8336, ..., 1.7263, -1.5512, 2.4111],\n",
+ " [ 3.4532, -2.9259, -1.6578, ..., 3.4532, -1.8388, 1.4622],\n",
+ " ...,\n",
+ " [-3.1650, 1.7098, -1.7899, ..., 3.3786, 2.3959, 0.5995],\n",
+ " [-1.4419, 0.8861, 2.4177, ..., -2.7610, -0.7628, 2.6093],\n",
+ " [ 2.0784, -3.4497, -2.4344, ..., -2.2582, -0.4973, 2.0179]])\n",
+ "Gradient - tensor(1.00000e-02 *\n",
+ " [[ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000],\n",
+ " [-0.2836, -0.2836, -0.2836, ..., -0.2836, -0.2836, -0.2836],\n",
+ " [ 0.1898, 0.1898, 0.1898, ..., 0.1898, 0.1898, 0.1898],\n",
+ " ...,\n",
+ " [-0.2426, -0.2426, -0.2426, ..., -0.2426, -0.2426, -0.2426],\n",
+ " [-0.0191, -0.0191, -0.0191, ..., -0.0191, -0.0191, -0.0191],\n",
+ " [-0.0097, -0.0097, -0.0097, ..., -0.0097, -0.0097, -0.0097]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "print('Initial weights - ', model[0].weight)\n",
+ "\n",
+ "images, labels = next(iter(trainloader))\n",
+ "images.resize_(64, 784)\n",
+ "\n",
+ "# Clear the gradients, do this because gradients are accumulated\n",
+ "optimizer.zero_grad()\n",
+ "\n",
+ "# Forward pass, then backward pass, then update weights\n",
+ "output = model.forward(images)\n",
+ "loss = criterion(output, labels)\n",
+ "loss.backward()\n",
+ "print('Gradient -', model[0].weight.grad)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Updated weights - Parameter containing:\n",
+ "tensor([[-2.7038e-02, 1.9887e-02, 3.2999e-02, ..., 8.4956e-03,\n",
+ " -2.6579e-02, -8.6528e-03],\n",
+ " [ 2.2148e-02, 3.2703e-02, 1.8365e-02, ..., 1.7291e-02,\n",
+ " -1.5484e-02, 2.4139e-02],\n",
+ " [ 3.4513e-02, -2.9278e-02, -1.6597e-02, ..., 3.4513e-02,\n",
+ " -1.8407e-02, 1.4603e-02],\n",
+ " ...,\n",
+ " [-3.1626e-02, 1.7122e-02, -1.7874e-02, ..., 3.3810e-02,\n",
+ " 2.3983e-02, 6.0188e-03],\n",
+ " [-1.4417e-02, 8.8628e-03, 2.4179e-02, ..., -2.7608e-02,\n",
+ " -7.6258e-03, 2.6094e-02],\n",
+ " [ 2.0785e-02, -3.4496e-02, -2.4343e-02, ..., -2.2581e-02,\n",
+ " -4.9718e-03, 2.0180e-02]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Take an update step and few the new weights\n",
+ "optimizer.step()\n",
+ "print('Updated weights - ', model[0].weight)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Training for real\n",
+ "\n",
+ "Now we'll put this algorithm into a loop so we can go through all the images. Some nomenclature, one pass through the entire dataset is called an *epoch*. So here we're going to loop through `trainloader` to get our training batches. For each batch, we'll doing a training pass where we calculate the loss, do a backwards pass, and update the weights.\n",
+ "\n",
+ ">**Exercise:** Implement the training pass for our network. If you implemented it correctly, you should see the training loss drop with each epoch."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Parameter containing:\n",
+ "tensor([[-2.7038e-02, 1.9887e-02, 3.2999e-02, ..., 8.4956e-03,\n",
+ " -2.6579e-02, -8.6528e-03],\n",
+ " [ 2.2148e-02, 3.2703e-02, 1.8365e-02, ..., 1.7291e-02,\n",
+ " -1.5484e-02, 2.4139e-02],\n",
+ " [ 3.4513e-02, -2.9278e-02, -1.6597e-02, ..., 3.4513e-02,\n",
+ " -1.8407e-02, 1.4603e-02],\n",
+ " ...,\n",
+ " [-3.1626e-02, 1.7122e-02, -1.7874e-02, ..., 3.3810e-02,\n",
+ " 2.3983e-02, 6.0188e-03],\n",
+ " [-1.4417e-02, 8.8628e-03, 2.4179e-02, ..., -2.7608e-02,\n",
+ " -7.6258e-03, 2.6094e-02],\n",
+ " [ 2.0785e-02, -3.4496e-02, -2.4343e-02, ..., -2.2581e-02,\n",
+ " -4.9718e-03, 2.0180e-02]])\n",
+ "Parameter containing:\n",
+ "tensor(1.00000e-02 *\n",
+ " [ 3.3668, 0.7419, -1.8832, 3.3459, -1.2885, 2.3498, -3.2847,\n",
+ " -2.5125, 1.2113, 0.9952, 0.9553, 2.6171, -3.3212, -0.0938,\n",
+ " -2.4987, 3.5654, -0.0948, 1.7207, -2.3500, -1.9280, 2.4983,\n",
+ " -0.7706, -0.8420, 1.0975, 2.1482, 1.1367, 2.0218, -3.2644,\n",
+ " -2.3274, -0.7202, -3.2821, 0.8014, 1.2345, -0.6529, -0.8498,\n",
+ " 1.2524, -1.3299, 0.9776, -0.4898, -1.0730, -3.5097, -1.4012,\n",
+ " -2.7926, 0.8974, 3.0059, 2.6043, 0.9115, -1.5502, -3.5404,\n",
+ " 2.3430, 0.1960, 1.9573, 0.0817, 2.7596, -1.2438, 0.1364,\n",
+ " -2.0851, 0.8863, -3.5209, 2.5510, 0.1684, 2.5416, -1.9530,\n",
+ " 0.5968, 2.5971, -2.3745, -3.0792, -3.1208, -2.2553, -3.4898,\n",
+ " 1.1541, 3.1804, -1.1212, 2.2470, 1.0808, 0.8310, 1.2837,\n",
+ " -1.7779, -1.6034, 2.6021, 2.1201, 1.6791, -2.4881, 0.5171,\n",
+ " -0.8303, -0.3989, 0.0729, 1.6734, 1.8116, -1.7574, 2.0754,\n",
+ " 0.0821, 2.7436, -0.4718, -3.4319, 1.6395, 3.0917, -2.0894,\n",
+ " -0.9218, -0.9748, 0.7447, 1.4246, 1.3142, 0.1103, -3.3546,\n",
+ " -2.9479, 1.2459, 0.3943, -1.6950, -2.2550, -3.3813, 2.1158,\n",
+ " 1.4592, -1.8017, 2.4179, 0.0491, 2.9096, -1.5254, -0.4820,\n",
+ " 0.3837, -1.3550, 1.3072, 1.3357, 1.1340, 3.2454, 2.2717,\n",
+ " 1.1681, -2.5664])\n",
+ "Parameter containing:\n",
+ "tensor(1.00000e-02 *\n",
+ " [[ 6.6118, -5.8799, -5.6224, ..., -2.8308, 1.6130, 2.3117],\n",
+ " [ 5.6230, -7.6402, -3.0842, ..., -3.8696, 6.2061, -5.9002],\n",
+ " [-3.8905, 6.3519, -5.9665, ..., -0.1648, -2.1185, -1.2933],\n",
+ " ...,\n",
+ " [ 6.8186, 8.6024, -6.3402, ..., -7.1725, 1.5164, 0.4358],\n",
+ " [-2.5287, -1.2489, 3.1559, ..., 5.4540, -0.7595, -4.3730],\n",
+ " [ 4.9476, -3.3993, 1.2295, ..., 8.5481, -7.4347, 4.5469]])\n",
+ "Parameter containing:\n",
+ "tensor(1.00000e-02 *\n",
+ " [-4.2665, -8.4224, 3.8957, -4.5744, -5.5559, -1.9764, -5.7001,\n",
+ " -0.7511, -6.2323, -4.1819, 7.6090, -4.4706, -3.8207, 2.9006,\n",
+ " 5.1528, 7.7814, 5.3032, 2.4000, 7.3391, -4.7441, 4.2543,\n",
+ " 4.4049, -1.3232, 5.0152, -1.6704, -4.5327, 1.2556, -0.0931,\n",
+ " -8.7371, 7.8578, 3.7794, 4.6325, -6.3968, -3.6761, 6.5102,\n",
+ " 2.2799, 5.7632, -8.4905, -4.4629, 3.5130, -6.7430, 3.7210,\n",
+ " 4.5112, -7.3436, -6.4811, 6.3507, 6.6141, 4.2889, 2.2299,\n",
+ " -1.1551, -7.1582, 4.3566, -3.2439, 6.8339, -7.5185, 3.7190,\n",
+ " -2.6939, -0.1771, 4.0041, -6.9810, -3.5107, -3.7741, 8.7073,\n",
+ " 0.9784])\n",
+ "Parameter containing:\n",
+ "tensor([[-0.1156, 0.0478, 0.0616, -0.0066, -0.0416, 0.0679, 0.0206,\n",
+ " 0.0655, -0.0790, 0.0835, 0.0760, 0.1124, 0.0986, -0.0493,\n",
+ " -0.0347, 0.0515, 0.1063, 0.0494, 0.0595, 0.0682, 0.1170,\n",
+ " 0.0899, -0.1067, 0.0376, 0.0708, 0.0139, -0.1158, 0.0311,\n",
+ " -0.0509, 0.0421, 0.0182, 0.0832, -0.0492, 0.0312, -0.0999,\n",
+ " -0.0778, 0.0766, 0.0154, -0.0489, -0.0173, 0.1053, -0.0114,\n",
+ " -0.1161, -0.0816, 0.0791, 0.0699, -0.0501, -0.0844, -0.0436,\n",
+ " 0.0475, -0.1048, -0.0036, 0.0216, -0.0255, -0.0483, 0.0618,\n",
+ " -0.1012, 0.0282, 0.1031, 0.0963, -0.0339, -0.0409, -0.0900,\n",
+ " 0.0780],\n",
+ " [-0.1092, 0.0088, -0.0426, 0.0808, 0.1203, -0.0687, 0.0719,\n",
+ " -0.0458, 0.0621, -0.0764, -0.0596, 0.0524, 0.0561, -0.0782,\n",
+ " -0.0837, 0.0204, 0.1058, -0.1158, -0.1138, -0.0045, 0.0377,\n",
+ " -0.1221, 0.0042, -0.0447, -0.0881, -0.0242, 0.0043, 0.0937,\n",
+ " 0.1025, -0.1106, 0.0193, 0.0884, 0.0952, 0.0523, -0.0701,\n",
+ " 0.0619, -0.0630, -0.0392, 0.0586, -0.0436, 0.0939, 0.1035,\n",
+ " -0.0818, 0.1120, -0.1231, 0.0135, 0.0916, 0.0524, -0.0912,\n",
+ " 0.0338, -0.0286, 0.0630, -0.0029, -0.0016, 0.0476, 0.1196,\n",
+ " 0.0622, -0.0497, 0.0627, 0.0528, 0.0707, -0.0206, -0.0481,\n",
+ " -0.0057],\n",
+ " [-0.0746, 0.1005, 0.1051, -0.0218, 0.0296, 0.0880, 0.0444,\n",
+ " -0.0073, -0.1095, -0.1090, 0.1074, 0.0169, -0.0584, -0.0759,\n",
+ " 0.0731, 0.0007, -0.0929, -0.1037, 0.0466, 0.0908, 0.0439,\n",
+ " 0.0965, 0.0031, -0.0598, 0.0400, 0.0020, 0.0759, 0.0121,\n",
+ " -0.0259, -0.0308, -0.0550, -0.0732, -0.0540, -0.0185, 0.0064,\n",
+ " 0.0245, 0.0490, -0.0285, 0.0665, -0.0285, -0.0247, 0.0209,\n",
+ " -0.0813, -0.0742, 0.0530, -0.0962, -0.0915, 0.0179, -0.0471,\n",
+ " 0.0476, 0.0992, 0.0732, -0.0714, 0.0505, 0.0211, 0.0166,\n",
+ " 0.0320, -0.0982, -0.0344, -0.0764, 0.0429, 0.0872, 0.0424,\n",
+ " 0.0147],\n",
+ " [-0.0164, -0.0382, -0.0536, -0.0941, 0.0881, -0.0055, -0.0429,\n",
+ " 0.0311, -0.1157, 0.0331, -0.1165, -0.0494, 0.0229, -0.0027,\n",
+ " -0.0877, 0.0723, 0.0355, -0.0309, 0.0930, 0.0279, 0.0324,\n",
+ " -0.0833, -0.1145, 0.0684, -0.0048, -0.0678, 0.0104, 0.0794,\n",
+ " -0.0760, 0.0932, -0.0475, 0.1190, 0.0043, -0.0639, -0.0486,\n",
+ " -0.1066, 0.0610, 0.0843, 0.0696, -0.0143, 0.0524, -0.0314,\n",
+ " -0.0708, -0.0492, 0.0120, -0.1079, -0.0514, -0.1059, -0.1088,\n",
+ " 0.0988, -0.0305, -0.0849, 0.0158, -0.0824, 0.1033, -0.0051,\n",
+ " -0.0442, -0.0562, -0.1185, -0.0407, 0.0941, -0.0040, 0.0132,\n",
+ " -0.0754],\n",
+ " [ 0.0938, 0.1147, 0.0023, -0.0157, -0.0163, 0.1141, 0.1167,\n",
+ " -0.0423, 0.0170, -0.0370, -0.0245, -0.1108, -0.0043, 0.0700,\n",
+ " -0.0491, 0.1237, -0.0400, -0.1136, 0.1244, 0.0252, -0.0029,\n",
+ " -0.0106, 0.0356, -0.0449, -0.0110, 0.0670, -0.0550, -0.0638,\n",
+ " 0.1102, 0.0690, -0.1191, 0.0004, 0.0185, 0.0207, 0.0258,\n",
+ " -0.0651, -0.0515, -0.0399, -0.0194, -0.0138, 0.0962, 0.0952,\n",
+ " -0.0591, 0.1115, 0.0217, -0.0004, 0.0801, 0.1140, -0.0576,\n",
+ " -0.0994, 0.0473, 0.0969, 0.0528, -0.1126, 0.0189, 0.0094,\n",
+ " 0.0853, 0.1138, -0.0919, -0.0234, -0.0754, 0.0672, -0.0215,\n",
+ " -0.1048],\n",
+ " [ 0.1191, 0.1056, -0.0127, 0.0916, -0.0624, -0.0694, 0.0523,\n",
+ " -0.0315, 0.0693, 0.1197, -0.0222, 0.0428, 0.1163, -0.0914,\n",
+ " -0.0285, -0.0261, -0.0901, -0.1024, 0.0669, 0.0541, 0.0612,\n",
+ " 0.1061, 0.0176, -0.0266, -0.0117, -0.1171, 0.0448, -0.0451,\n",
+ " 0.0740, -0.0085, -0.0433, 0.1239, 0.0014, 0.0595, -0.0222,\n",
+ " 0.0242, -0.1162, -0.0992, 0.1196, -0.0826, 0.0745, 0.1157,\n",
+ " 0.0178, -0.0370, 0.0617, -0.0736, 0.1169, 0.0245, 0.0838,\n",
+ " -0.1123, 0.1202, -0.0781, 0.0130, -0.1246, 0.1007, 0.1031,\n",
+ " 0.0280, -0.1056, 0.1004, 0.0594, -0.0396, 0.0640, -0.1247,\n",
+ " 0.0525],\n",
+ " [ 0.0985, -0.0683, -0.1202, -0.0508, 0.0315, -0.1193, -0.0622,\n",
+ " 0.1096, -0.0646, -0.0668, -0.1205, 0.0505, 0.1117, -0.0098,\n",
+ " -0.0791, -0.0047, 0.0948, 0.1165, 0.1093, -0.0008, 0.1132,\n",
+ " -0.0794, -0.0297, 0.0950, 0.0144, 0.0130, 0.1033, 0.0345,\n",
+ " -0.0381, -0.0196, 0.0834, 0.0524, 0.0292, 0.1210, -0.0037,\n",
+ " -0.1051, -0.0395, -0.0169, -0.0704, -0.1053, -0.0806, -0.0609,\n",
+ " 0.0266, 0.1034, 0.0929, -0.1187, 0.0170, 0.0521, 0.0566,\n",
+ " 0.1137, -0.0370, 0.0997, -0.1121, 0.0793, -0.0370, 0.0375,\n",
+ " -0.1243, 0.0818, -0.0093, 0.0325, -0.0824, 0.0870, -0.1134,\n",
+ " 0.0516],\n",
+ " [ 0.0630, 0.0979, 0.1116, 0.0468, 0.0581, 0.0167, 0.0566,\n",
+ " 0.0487, -0.0610, -0.1248, 0.1037, 0.0113, -0.0857, -0.0064,\n",
+ " -0.0544, -0.1025, 0.1028, -0.0504, -0.0179, 0.0860, 0.0311,\n",
+ " 0.0570, -0.0606, -0.0050, 0.1080, 0.0421, -0.0743, -0.0743,\n",
+ " 0.0574, -0.0788, -0.0008, 0.0033, -0.0681, 0.0608, 0.0709,\n",
+ " 0.0534, -0.0943, 0.0017, 0.0309, -0.0405, -0.0831, -0.1093,\n",
+ " -0.0639, 0.0849, -0.0586, -0.0784, -0.0013, 0.0146, -0.0718,\n",
+ " 0.0621, -0.0744, -0.0070, -0.0853, -0.0287, -0.0907, 0.0585,\n",
+ " 0.0701, -0.0735, -0.0663, 0.0744, -0.0495, -0.0306, -0.0157,\n",
+ " 0.0674],\n",
+ " [-0.1175, 0.0135, -0.0159, 0.1169, 0.1150, -0.0593, 0.1114,\n",
+ " 0.0051, 0.1246, -0.1125, -0.0935, 0.0661, -0.0983, 0.0082,\n",
+ " 0.0973, 0.0323, -0.0007, 0.1161, -0.0085, 0.0322, 0.0122,\n",
+ " 0.0803, 0.0136, 0.0047, 0.0970, 0.0295, -0.0083, 0.0325,\n",
+ " -0.0336, -0.0414, 0.1043, 0.0433, 0.0486, -0.0818, -0.0341,\n",
+ " 0.0878, 0.0607, 0.0399, 0.1129, 0.1141, 0.1010, 0.0923,\n",
+ " -0.0500, -0.1137, -0.0929, -0.0015, -0.0390, 0.1137, 0.1152,\n",
+ " -0.0941, 0.1011, 0.0285, 0.0942, 0.0853, -0.1022, 0.1209,\n",
+ " 0.0605, -0.0964, 0.0687, 0.0762, -0.0920, 0.0930, -0.0598,\n",
+ " -0.0363],\n",
+ " [ 0.0675, -0.0126, -0.0291, 0.1144, 0.0427, 0.1141, -0.0564,\n",
+ " -0.1134, -0.0879, 0.0917, 0.0895, -0.0589, 0.1166, 0.0081,\n",
+ " 0.0092, 0.0726, 0.0485, -0.0497, 0.1212, -0.0607, -0.0025,\n",
+ " 0.0066, 0.0369, -0.1079, 0.0571, -0.0955, 0.1071, 0.0222,\n",
+ " -0.0096, -0.0946, 0.0068, 0.0222, 0.0417, -0.0834, 0.0503,\n",
+ " -0.0290, -0.0980, -0.0585, -0.0479, 0.0470, -0.0598, -0.0981,\n",
+ " 0.0652, -0.0065, -0.0511, -0.0315, -0.0483, -0.0538, -0.0438,\n",
+ " -0.0818, -0.0593, -0.1167, -0.0972, -0.1077, -0.0861, -0.0792,\n",
+ " 0.0165, 0.0559, 0.0547, -0.0204, -0.1176, -0.1241, -0.0117,\n",
+ " -0.0134]])\n",
+ "Parameter containing:\n",
+ "tensor([-0.0605, -0.1067, -0.0319, -0.0027, 0.0564, 0.0976, 0.0972,\n",
+ " -0.0675, -0.0780, -0.1053])\n"
+ ]
+ }
+ ],
+ "source": [
+ "for i in model.parameters():\n",
+ " print(i)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Training loss: 1.950723188518207\n",
+ "Training loss: 0.8936214096256411\n",
+ "Training loss: 0.5425369234672234\n",
+ "Training loss: 0.4404041236206921\n",
+ "Training loss: 0.3902943800094285\n"
+ ]
+ }
+ ],
+ "source": [
+ "## Your solution here\n",
+ "\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))\n",
+ "\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.SGD(model.parameters(), lr=0.003)\n",
+ "\n",
+ "epochs = 5\n",
+ "for e in range(epochs):\n",
+ " running_loss = 0\n",
+ " for images, labels in trainloader:\n",
+ " # Flatten MNIST images into a 784 long vector\n",
+ " images = images.view(images.shape[0], -1)\n",
+ " \n",
+ " # TODO: Training pass\n",
+ " # Zero the gradients\n",
+ " optimizer.zero_grad()\n",
+ " # Do a forward pass and get output\n",
+ " output = model.forward(images)\n",
+ " # Calculate loss\n",
+ " loss = criterion(output, labels)\n",
+ " # Do a backwards pass to find gradients\n",
+ " loss.backward()\n",
+ " # Update weights\n",
+ " optimizer.step()\n",
+ " \n",
+ " running_loss += loss.item()\n",
+ " else:\n",
+ " print(f\"Training loss: {running_loss/len(trainloader)}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "366.09612844884396"
+ ]
+ },
+ "execution_count": 32,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "running_loss"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "With the network trained, we can check out it's predictions."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%matplotlib inline\n",
+ "import helper\n",
+ "\n",
+ "images, labels = next(iter(trainloader))\n",
+ "\n",
+ "img = images[0].view(1, 784)\n",
+ "# Turn off gradients to speed up this part\n",
+ "with torch.no_grad():\n",
+ " logits = model.forward(img)\n",
+ "\n",
+ "# Output of the network are logits, need to take softmax for probabilities\n",
+ "ps = F.softmax(logits, dim=1)\n",
+ "helper.view_classify(img.view(1, 28, 28), ps)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[ 1.0032e-05, 2.0539e-05, 4.5163e-06, 2.1405e-04, 8.1418e-02,\n",
+ " 1.4443e-03, 1.3010e-05, 6.3836e-01, 1.1517e-03, 2.7737e-01]])"
+ ]
+ },
+ "execution_count": 34,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "ps"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now our network is brilliant. It can accurately predict the digits in our images. Next up you'll write the code for training a neural network on a more complex dataset."
+ ]
+ }
+ ],
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 4 - Fashion-MNIST (Exercises).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 4 - Fashion-MNIST (Exercises).ipynb
new file mode 100644
index 0000000..cf2e9d7
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 4 - Fashion-MNIST (Exercises).ipynb
@@ -0,0 +1,269 @@
+{
+ "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",
+ "\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": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n",
+ "Processing...\n",
+ "Done!\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "from torchvision import datasets, transforms\n",
+ "import helper\n",
+ "\n",
+ "# Define a transform to normalize the data\n",
+ "transform = transforms.Compose([transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 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": "markdown",
+ "metadata": {},
+ "source": [
+ "Here we can see one of the images."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "image, label = next(iter(trainloader))\n",
+ "helper.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",
+ "\n",
+ "# Import modules\n",
+ "from torch import nn, optim\n",
+ "import torch.nn.functional as F"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model = nn.Sequential(nn.Linear(784, 256),\n",
+ " nn.ReLU(),\n",
+ " nn.Linear(256, 128),\n",
+ " nn.ReLU(),\n",
+ " nn.Linear(128, 64),\n",
+ " nn.ReLU(),\n",
+ " nn.Linear(64, 10),\n",
+ " nn.LogSoftmax(dim=1))"
+ ]
+ },
+ {
+ "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": 24,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# TODO: Create the network, define the criterion and optimizer\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.Adam(model.parameters(), lr=0.003)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Training loss: 0.5202356389940166\n",
+ "Training loss: 0.3878176898431422\n",
+ "Training loss: 0.3550535404860084\n",
+ "Training loss: 0.3305503525761272\n",
+ "Training loss: 0.31469793412000385\n"
+ ]
+ }
+ ],
+ "source": [
+ "# TODO: Train the network here\n",
+ "epochs = 5\n",
+ "\n",
+ "for e in range(epochs):\n",
+ " running_loss = 0\n",
+ " for image, label in trainloader:\n",
+ " # Flatten images\n",
+ " image = image.view(image.shape[0], -1)\n",
+ " \n",
+ " # Zero the gradients\n",
+ " optimizer.zero_grad()\n",
+ " \n",
+ " # Do a forward pass\n",
+ " log_ps = model.forward(image)\n",
+ " \n",
+ " # Calculate loss\n",
+ " loss = criterion(log_ps, label)\n",
+ " \n",
+ " # Do a backward pass to find gradients\n",
+ " loss.backward()\n",
+ " \n",
+ " # Update weights\n",
+ " optimizer.step()\n",
+ " \n",
+ " running_loss += loss.item()\n",
+ " else:\n",
+ " print(f'Training loss: {running_loss/len(trainloader)}')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 204,
+ "width": 423
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import helper\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",
+ "# TODO: Calculate the class probabilities (softmax) for img\n",
+ "ps = torch.exp(model(img))\n",
+ "\n",
+ "# Plot the image and probabilities\n",
+ "helper.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",
+ "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
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 4 - Fashion-MNIST (Solution).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 4 - Fashion-MNIST (Solution).ipynb
new file mode 100644
index 0000000..6618e9d
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 4 - Fashion-MNIST (Solution).ipynb
@@ -0,0 +1,242 @@
+{
+ "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",
+ "\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": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "from torchvision import datasets, transforms\n",
+ "import helper\n",
+ "\n",
+ "# Define a transform to normalize the data\n",
+ "transform = transforms.Compose([transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 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": "markdown",
+ "metadata": {},
+ "source": [
+ "Here we can see one of the images."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "image, label = next(iter(trainloader))\n",
+ "helper.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": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from torch import nn, optim\n",
+ "import torch.nn.functional as F"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# TODO: Define your network architecture here\n",
+ "class Classifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.fc1 = nn.Linear(784, 256)\n",
+ " self.fc2 = nn.Linear(256, 128)\n",
+ " self.fc3 = nn.Linear(128, 64)\n",
+ " self.fc4 = nn.Linear(64, 10)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # make sure input tensor is flattened\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": "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` or `nn.NLLLoss`) 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": 13,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# TODO: Create the network, define the criterion and optimizer\n",
+ "model = Classifier()\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.Adam(model.parameters(), lr=0.003)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Training loss: 283.4510831311345\n",
+ "Training loss: 274.7842669263482\n",
+ "Training loss: 267.907463490963\n",
+ "Training loss: 258.2156918346882\n",
+ "Training loss: 251.79347000271082\n"
+ ]
+ }
+ ],
+ "source": [
+ "# TODO: Train the network here\n",
+ "epochs = 5\n",
+ "\n",
+ "for e in range(epochs):\n",
+ " running_loss = 0\n",
+ " for images, labels in trainloader:\n",
+ " log_ps = model(images)\n",
+ " loss = criterion(log_ps, labels)\n",
+ " \n",
+ " optimizer.zero_grad()\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ " \n",
+ " running_loss += loss.item()\n",
+ " else:\n",
+ " print(f\"Training loss: {running_loss}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 204,
+ "width": 423
+ }
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import helper\n",
+ "\n",
+ "# Test out your network!\n",
+ "\n",
+ "dataiter = iter(testloader)\n",
+ "images, labels = dataiter.next()\n",
+ "img = images[1]\n",
+ "\n",
+ "# TODO: Calculate the class probabilities (softmax) for img\n",
+ "ps = torch.exp(model(img))\n",
+ "\n",
+ "# Plot the image and probabilities\n",
+ "helper.view_classify(img, ps, version='Fashion')"
+ ]
+ }
+ ],
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 5 - Inference and Validation (Exercises).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 5 - Inference and Validation (Exercises).ipynb
new file mode 100644
index 0000000..037ca40
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 5 - Inference and Validation (Exercises).ipynb
@@ -0,0 +1,894 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Inference and Validation\n",
+ "\n",
+ "Now that you have a trained network, you can use it for making predictions. This is typically called **inference**, a term borrowed from statistics. However, neural networks have a tendency to perform *too well* on the training data and aren't able to generalize to data that hasn't been seen before. This is called **overfitting** and it impairs inference performance. To test for overfitting while training, we measure the performance on data not in the training set called the **validation** set. We avoid overfitting through regularization such as dropout while monitoring the validation performance during training. In this notebook, I'll show you how to do this in PyTorch. \n",
+ "\n",
+ "As usual, let's start by loading the dataset through torchvision. You'll learn more about torchvision and loading data in a later part. This time we'll be taking advantage of the test set which you can get by setting `train=False` here:\n",
+ "\n",
+ "```python\n",
+ "testset = datasets.FashionMNIST('~/.pytorch/F_MNIST_data/', download=True, train=False, transform=transform)\n",
+ "```\n",
+ "\n",
+ "The test set contains images just like the training set. Typically you'll see 10-20% of the original dataset held out for testing and validation with the rest being used for training."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Define a transform to normalize the data\n",
+ "transform = transforms.Compose([transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 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": "markdown",
+ "metadata": {},
+ "source": [
+ "Here I'll create a model like normal, using the same one from my solution for part 4."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from torch import nn, optim\n",
+ "import torch.nn.functional as F\n",
+ "\n",
+ "class Classifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.fc1 = nn.Linear(784, 256)\n",
+ " self.fc2 = nn.Linear(256, 128)\n",
+ " self.fc3 = nn.Linear(128, 64)\n",
+ " self.fc4 = nn.Linear(64, 10)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # make sure input tensor is flattened\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": "markdown",
+ "metadata": {},
+ "source": [
+ "The goal of validation is to measure the model's performance on data that isn't part of the training set. Performance here is up to the developer to define though. Typically this is just accuracy, the percentage of classes the network predicted correctly. Other options are [precision and recall](https://en.wikipedia.org/wiki/Precision_and_recall#Definition_(classification_context)) and top-5 error rate. We'll focus on accuracy here. First I'll do a forward pass with one batch from the test set."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "torch.Size([64, 10])\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = Classifier()\n",
+ "\n",
+ "images, labels = next(iter(testloader))\n",
+ "# Get the class probabilities\n",
+ "ps = torch.exp(model(images))\n",
+ "# Make sure the shape is appropriate, we should get 10 class probabilities for 64 examples\n",
+ "print(ps.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "With the probabilities, we can get the most likely class using the `ps.topk` method. This returns the $k$ highest values. Since we just want the most likely class, we can use `ps.topk(1)`. This returns a tuple of the top-$k$ values and the top-$k$ indices. If the highest value is the fifth element, we'll get back 4 as the index."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 9],\n",
+ " [ 9],\n",
+ " [ 9],\n",
+ " [ 9],\n",
+ " [ 9],\n",
+ " [ 9],\n",
+ " [ 9],\n",
+ " [ 9],\n",
+ " [ 7],\n",
+ " [ 9]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "top_p, top_class = ps.topk(1, dim=1)\n",
+ "# Look at the most likely classes for the first 10 examples\n",
+ "print(top_class[:10,:])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we can check if the predicted classes match the labels. This is simple to do by equating `top_class` and `labels`, but we have to be careful of the shapes. Here `top_class` is a 2D tensor with shape `(64, 1)` while `labels` is 1D with shape `(64)`. To get the equality to work out the way we want, `top_class` and `labels` must have the same shape.\n",
+ "\n",
+ "If we do\n",
+ "\n",
+ "```python\n",
+ "equals = top_class == labels\n",
+ "```\n",
+ "\n",
+ "`equals` will have shape `(64, 64)`, try it yourself. What it's doing is comparing the one element in each row of `top_class` with each element in `labels` which returns 64 True/False boolean values for each row."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "equals = top_class == labels.view(*top_class.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we need to calculate the percentage of correct predictions. `equals` has binary values, either 0 or 1. This means that if we just sum up all the values and divide by the number of values, we get the percentage of correct predictions. This is the same operation as taking the mean, so we can get the accuracy with a call to `torch.mean`. If only it was that simple. If you try `torch.mean(equals)`, you'll get an error\n",
+ "\n",
+ "```\n",
+ "RuntimeError: mean is not implemented for type torch.ByteTensor\n",
+ "```\n",
+ "\n",
+ "This happens because `equals` has type `torch.ByteTensor` but `torch.mean` isn't implemented for tensors with that type. So we'll need to convert `equals` to a float tensor. Note that when we take `torch.mean` it returns a scalar tensor, to get the actual value as a float we'll need to do `accuracy.item()`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Accuracy: 18.75%\n"
+ ]
+ }
+ ],
+ "source": [
+ "accuracy = torch.mean(equals.type(torch.FloatTensor))\n",
+ "print(f'Accuracy: {accuracy.item()*100}%')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The network is untrained so it's making random guesses and we should see an accuracy around 10%. Now let's train our network and include our validation pass so we can measure how well the network is performing on the test set. Since we're not updating our parameters in the validation pass, we can speed up our code by turning off gradients using `torch.no_grad()`:\n",
+ "\n",
+ "```python\n",
+ "# turn off gradients\n",
+ "with torch.no_grad():\n",
+ " # validation pass here\n",
+ " for images, labels in testloader:\n",
+ " ...\n",
+ "```\n",
+ "\n",
+ ">**Exercise:** Implement the validation loop below and print out the total accuracy after the loop. You can largely copy and paste the code from above, but I suggest typing it in because writing it out yourself is essential for building the skill. In general you'll always learn more by typing it rather than copy-pasting. You should be able to get an accuracy above 80%."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 1 out of 30\n",
+ "Training Loss: 0.511\n",
+ "Test Loss: 0.462\n",
+ "Test Accuracy: 0.833\n",
+ "Epoch: 2 out of 30\n",
+ "Training Loss: 0.389\n",
+ "Test Loss: 0.415\n",
+ "Test Accuracy: 0.854\n",
+ "Epoch: 3 out of 30\n",
+ "Training Loss: 0.353\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.861\n",
+ "Epoch: 4 out of 30\n",
+ "Training Loss: 0.331\n",
+ "Test Loss: 0.375\n",
+ "Test Accuracy: 0.867\n",
+ "Epoch: 5 out of 30\n",
+ "Training Loss: 0.313\n",
+ "Test Loss: 0.374\n",
+ "Test Accuracy: 0.868\n",
+ "Epoch: 6 out of 30\n",
+ "Training Loss: 0.301\n",
+ "Test Loss: 0.374\n",
+ "Test Accuracy: 0.866\n",
+ "Epoch: 7 out of 30\n",
+ "Training Loss: 0.293\n",
+ "Test Loss: 0.381\n",
+ "Test Accuracy: 0.866\n",
+ "Epoch: 8 out of 30\n",
+ "Training Loss: 0.282\n",
+ "Test Loss: 0.381\n",
+ "Test Accuracy: 0.869\n",
+ "Epoch: 9 out of 30\n",
+ "Training Loss: 0.274\n",
+ "Test Loss: 0.370\n",
+ "Test Accuracy: 0.873\n",
+ "Epoch: 10 out of 30\n",
+ "Training Loss: 0.268\n",
+ "Test Loss: 0.402\n",
+ "Test Accuracy: 0.864\n",
+ "Epoch: 11 out of 30\n",
+ "Training Loss: 0.261\n",
+ "Test Loss: 0.368\n",
+ "Test Accuracy: 0.878\n",
+ "Epoch: 12 out of 30\n",
+ "Training Loss: 0.254\n",
+ "Test Loss: 0.367\n",
+ "Test Accuracy: 0.877\n",
+ "Epoch: 13 out of 30\n",
+ "Training Loss: 0.246\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.873\n",
+ "Epoch: 14 out of 30\n",
+ "Training Loss: 0.242\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.880\n",
+ "Epoch: 15 out of 30\n",
+ "Training Loss: 0.236\n",
+ "Test Loss: 0.374\n",
+ "Test Accuracy: 0.879\n",
+ "Epoch: 16 out of 30\n",
+ "Training Loss: 0.227\n",
+ "Test Loss: 0.366\n",
+ "Test Accuracy: 0.883\n",
+ "Epoch: 17 out of 30\n",
+ "Training Loss: 0.228\n",
+ "Test Loss: 0.382\n",
+ "Test Accuracy: 0.879\n",
+ "Epoch: 18 out of 30\n",
+ "Training Loss: 0.229\n",
+ "Test Loss: 0.370\n",
+ "Test Accuracy: 0.885\n",
+ "Epoch: 19 out of 30\n",
+ "Training Loss: 0.219\n",
+ "Test Loss: 0.376\n",
+ "Test Accuracy: 0.882\n",
+ "Epoch: 20 out of 30\n",
+ "Training Loss: 0.212\n",
+ "Test Loss: 0.372\n",
+ "Test Accuracy: 0.882\n",
+ "Epoch: 21 out of 30\n",
+ "Training Loss: 0.212\n",
+ "Test Loss: 0.384\n",
+ "Test Accuracy: 0.878\n",
+ "Epoch: 22 out of 30\n",
+ "Training Loss: 0.206\n",
+ "Test Loss: 0.405\n",
+ "Test Accuracy: 0.882\n",
+ "Epoch: 23 out of 30\n",
+ "Training Loss: 0.210\n",
+ "Test Loss: 0.376\n",
+ "Test Accuracy: 0.888\n",
+ "Epoch: 24 out of 30\n",
+ "Training Loss: 0.199\n",
+ "Test Loss: 0.406\n",
+ "Test Accuracy: 0.884\n",
+ "Epoch: 25 out of 30\n",
+ "Training Loss: 0.212\n",
+ "Test Loss: 0.382\n",
+ "Test Accuracy: 0.885\n",
+ "Epoch: 26 out of 30\n",
+ "Training Loss: 0.195\n",
+ "Test Loss: 0.377\n",
+ "Test Accuracy: 0.885\n",
+ "Epoch: 27 out of 30\n",
+ "Training Loss: 0.201\n",
+ "Test Loss: 0.411\n",
+ "Test Accuracy: 0.881\n",
+ "Epoch: 28 out of 30\n",
+ "Training Loss: 0.185\n",
+ "Test Loss: 0.405\n",
+ "Test Accuracy: 0.883\n",
+ "Epoch: 29 out of 30\n",
+ "Training Loss: 0.185\n",
+ "Test Loss: 0.409\n",
+ "Test Accuracy: 0.887\n",
+ "Epoch: 30 out of 30\n",
+ "Training Loss: 0.186\n",
+ "Test Loss: 0.377\n",
+ "Test Accuracy: 0.888\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = Classifier()\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.Adam(model.parameters(), lr=0.003)\n",
+ "\n",
+ "epochs = 30\n",
+ "steps = 0\n",
+ "\n",
+ "trainLosses, testLosses = [], []\n",
+ "for e in range(epochs):\n",
+ " runningLoss = 0\n",
+ " for images, labels in trainloader:\n",
+ " \n",
+ " optimizer.zero_grad()\n",
+ " \n",
+ " log_ps = model(images)\n",
+ " loss = criterion(log_ps, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ " \n",
+ " runningLoss += loss.item()\n",
+ " \n",
+ " else:\n",
+ " ## TODO: Implement the validation pass and print out the validation accuracy\n",
+ " testLoss = 0\n",
+ " accuracy = 0\n",
+ " \n",
+ " # Turn off gradients for validation step\n",
+ " with torch.no_grad():\n",
+ " for images, labels in testloader:\n",
+ " # Get the output\n",
+ " log_ps = model(images)\n",
+ " # Get the loss\n",
+ " testLoss += criterion(log_ps, labels)\n",
+ " \n",
+ " # Get the probabilities\n",
+ " ps = torch.exp(log_ps)\n",
+ " # Get the most likely class for each prediction\n",
+ " top_p, top_class = ps.topk(1, dim=1)\n",
+ " # Check if the predictions match the actual label\n",
+ " equals = top_class == labels.view(*top_class.shape)\n",
+ " # Update accuracy\n",
+ " accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
+ " \n",
+ " # Update train loss\n",
+ " trainLosses.append(runningLoss/len(trainloader))\n",
+ " # Update test loss\n",
+ " testLosses.append(testLoss/len(testloader))\n",
+ " \n",
+ " # Print output\n",
+ " print(f'Epoch: {e+1} out of {epochs}')\n",
+ " print(f'Training Loss: {runningLoss/len(trainloader):.3f}')\n",
+ " print(f'Test Loss: {testLoss/len(testloader):.3f}')\n",
+ " print(f'Test Accuracy: {accuracy/len(testloader):.3f}')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 250,
+ "width": 380
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(trainLosses, label='Training loss')\n",
+ "plt.plot(testLosses, label='Validation loss')\n",
+ "plt.legend(frameon=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Overfitting\n",
+ "\n",
+ "If we look at the training and validation losses as we train the network, we can see a phenomenon known as overfitting.\n",
+ "\n",
+ "\n",
+ "\n",
+ "The network learns the training set better and better, resulting in lower training losses. However, it starts having problems generalizing to data outside the training set leading to the validation loss increasing. The ultimate goal of any deep learning model is to make predictions on new data, so we should strive to get the lowest validation loss possible. One option is to use the version of the model with the lowest validation loss, here the one around 8-10 training epochs. This strategy is called *early-stopping*. In practice, you'd save the model frequently as you're training then later choose the model with the lowest validation loss.\n",
+ "\n",
+ "The most common method to reduce overfitting (outside of early-stopping) is *dropout*, where we randomly drop input units. This forces the network to share information between weights, increasing it's ability to generalize to new data. Adding dropout in PyTorch is straightforward using the [`nn.Dropout`](https://pytorch.org/docs/stable/nn.html#torch.nn.Dropout) module.\n",
+ "\n",
+ "```python\n",
+ "class Classifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.fc1 = nn.Linear(784, 256)\n",
+ " self.fc2 = nn.Linear(256, 128)\n",
+ " self.fc3 = nn.Linear(128, 64)\n",
+ " self.fc4 = nn.Linear(64, 10)\n",
+ " \n",
+ " # Dropout module with 0.2 drop probability\n",
+ " self.dropout = nn.Dropout(p=0.2)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # make sure input tensor is flattened\n",
+ " x = x.view(x.shape[0], -1)\n",
+ " \n",
+ " # Now with dropout\n",
+ " x = self.dropout(F.relu(self.fc1(x)))\n",
+ " x = self.dropout(F.relu(self.fc2(x)))\n",
+ " x = self.dropout(F.relu(self.fc3(x)))\n",
+ " \n",
+ " # output so no dropout here\n",
+ " x = F.log_softmax(self.fc4(x), dim=1)\n",
+ " \n",
+ " return x\n",
+ "```\n",
+ "\n",
+ "During training we want to use dropout to prevent overfitting, but during inference we want to use the entire network. So, we need to turn off dropout during validation, testing, and whenever we're using the network to make predictions. To do this, you use `model.eval()`. This sets the model to evaluation mode where the dropout probability is 0. You can turn dropout back on by setting the model to train mode with `model.train()`. In general, the pattern for the validation loop will look like this, where you turn off gradients, set the model to evaluation mode, calculate the validation loss and metric, then set the model back to train mode.\n",
+ "\n",
+ "```python\n",
+ "# turn off gradients\n",
+ "with torch.no_grad():\n",
+ " \n",
+ " # set model to evaluation mode\n",
+ " model.eval()\n",
+ " \n",
+ " # validation pass here\n",
+ " for images, labels in testloader:\n",
+ " ...\n",
+ "\n",
+ "# set model back to train mode\n",
+ "model.train()\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "> **Exercise:** Add dropout to your model and train it on Fashion-MNIST again. See if you can get a lower validation loss or higher accuracy."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from torch import nn, optim\n",
+ "import torch.nn.functional as F\n",
+ "\n",
+ "class Classifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.fc1 = nn.Linear(784, 256)\n",
+ " self.fc2 = nn.Linear(256, 128)\n",
+ " self.fc3 = nn.Linear(128, 64)\n",
+ " self.fc4 = nn.Linear(64, 10)\n",
+ " \n",
+ " # Dropout module with 0.2 prob\n",
+ " self.dropout = nn.Dropout(p=0.2)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # make sure input tensor is flattened\n",
+ " x = x.view(x.shape[0], -1)\n",
+ " \n",
+ " # Apply dropout to inputs\n",
+ " x = self.dropout(F.relu(self.fc1(x)))\n",
+ " x = self.dropout(F.relu(self.fc2(x)))\n",
+ " x = self.dropout(F.relu(self.fc3(x)))\n",
+ " \n",
+ " # Output does not need dropout\n",
+ " x = F.log_softmax(self.fc4(x), dim=1)\n",
+ " \n",
+ " return x"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 1 out of 30\n",
+ "Training Loss: 0.615\n",
+ "Test Loss: 0.459\n",
+ "Test Accuracy: 0.836\n",
+ "Epoch: 2 out of 30\n",
+ "Training Loss: 0.484\n",
+ "Test Loss: 0.455\n",
+ "Test Accuracy: 0.844\n",
+ "Epoch: 3 out of 30\n",
+ "Training Loss: 0.455\n",
+ "Test Loss: 0.419\n",
+ "Test Accuracy: 0.846\n",
+ "Epoch: 4 out of 30\n",
+ "Training Loss: 0.436\n",
+ "Test Loss: 0.409\n",
+ "Test Accuracy: 0.856\n",
+ "Epoch: 5 out of 30\n",
+ "Training Loss: 0.416\n",
+ "Test Loss: 0.400\n",
+ "Test Accuracy: 0.857\n",
+ "Epoch: 6 out of 30\n",
+ "Training Loss: 0.414\n",
+ "Test Loss: 0.414\n",
+ "Test Accuracy: 0.853\n",
+ "Epoch: 7 out of 30\n",
+ "Training Loss: 0.406\n",
+ "Test Loss: 0.424\n",
+ "Test Accuracy: 0.853\n",
+ "Epoch: 8 out of 30\n",
+ "Training Loss: 0.408\n",
+ "Test Loss: 0.398\n",
+ "Test Accuracy: 0.866\n",
+ "Epoch: 9 out of 30\n",
+ "Training Loss: 0.395\n",
+ "Test Loss: 0.395\n",
+ "Test Accuracy: 0.868\n",
+ "Epoch: 10 out of 30\n",
+ "Training Loss: 0.387\n",
+ "Test Loss: 0.396\n",
+ "Test Accuracy: 0.854\n",
+ "Epoch: 11 out of 30\n",
+ "Training Loss: 0.384\n",
+ "Test Loss: 0.409\n",
+ "Test Accuracy: 0.862\n",
+ "Epoch: 12 out of 30\n",
+ "Training Loss: 0.380\n",
+ "Test Loss: 0.394\n",
+ "Test Accuracy: 0.864\n",
+ "Epoch: 13 out of 30\n",
+ "Training Loss: 0.382\n",
+ "Test Loss: 0.377\n",
+ "Test Accuracy: 0.870\n",
+ "Epoch: 14 out of 30\n",
+ "Training Loss: 0.372\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.869\n",
+ "Epoch: 15 out of 30\n",
+ "Training Loss: 0.382\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.867\n",
+ "Epoch: 16 out of 30\n",
+ "Training Loss: 0.374\n",
+ "Test Loss: 0.402\n",
+ "Test Accuracy: 0.861\n",
+ "Epoch: 17 out of 30\n",
+ "Training Loss: 0.368\n",
+ "Test Loss: 0.389\n",
+ "Test Accuracy: 0.870\n",
+ "Epoch: 18 out of 30\n",
+ "Training Loss: 0.368\n",
+ "Test Loss: 0.367\n",
+ "Test Accuracy: 0.869\n",
+ "Epoch: 19 out of 30\n",
+ "Training Loss: 0.363\n",
+ "Test Loss: 0.382\n",
+ "Test Accuracy: 0.871\n",
+ "Epoch: 20 out of 30\n",
+ "Training Loss: 0.361\n",
+ "Test Loss: 0.414\n",
+ "Test Accuracy: 0.863\n",
+ "Epoch: 21 out of 30\n",
+ "Training Loss: 0.368\n",
+ "Test Loss: 0.386\n",
+ "Test Accuracy: 0.866\n",
+ "Epoch: 22 out of 30\n",
+ "Training Loss: 0.358\n",
+ "Test Loss: 0.380\n",
+ "Test Accuracy: 0.876\n",
+ "Epoch: 23 out of 30\n",
+ "Training Loss: 0.351\n",
+ "Test Loss: 0.383\n",
+ "Test Accuracy: 0.866\n",
+ "Epoch: 24 out of 30\n",
+ "Training Loss: 0.353\n",
+ "Test Loss: 0.389\n",
+ "Test Accuracy: 0.868\n",
+ "Epoch: 25 out of 30\n",
+ "Training Loss: 0.351\n",
+ "Test Loss: 0.379\n",
+ "Test Accuracy: 0.864\n",
+ "Epoch: 26 out of 30\n",
+ "Training Loss: 0.354\n",
+ "Test Loss: 0.385\n",
+ "Test Accuracy: 0.873\n",
+ "Epoch: 27 out of 30\n",
+ "Training Loss: 0.350\n",
+ "Test Loss: 0.385\n",
+ "Test Accuracy: 0.871\n",
+ "Epoch: 28 out of 30\n",
+ "Training Loss: 0.350\n",
+ "Test Loss: 0.370\n",
+ "Test Accuracy: 0.876\n",
+ "Epoch: 29 out of 30\n",
+ "Training Loss: 0.346\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.869\n",
+ "Epoch: 30 out of 30\n",
+ "Training Loss: 0.338\n",
+ "Test Loss: 0.391\n",
+ "Test Accuracy: 0.872\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = Classifier()\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.Adam(model.parameters(), lr=0.003)\n",
+ "\n",
+ "epochs = 30\n",
+ "steps = 0\n",
+ "\n",
+ "trainLosses, testLosses = [], []\n",
+ "for e in range(epochs):\n",
+ " runningLoss = 0\n",
+ " for images, labels in trainloader:\n",
+ " \n",
+ " optimizer.zero_grad()\n",
+ " \n",
+ " log_ps = model(images)\n",
+ " loss = criterion(log_ps, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ " \n",
+ " runningLoss += loss.item()\n",
+ " \n",
+ " else:\n",
+ " ## TODO: Implement the validation pass and print out the validation accuracy\n",
+ " testLoss = 0\n",
+ " accuracy = 0\n",
+ " \n",
+ " # Turn off gradients for validation step\n",
+ " with torch.no_grad():\n",
+ " \n",
+ " # Set model to evaluation mode\n",
+ " model.eval()\n",
+ " \n",
+ " for images, labels in testloader:\n",
+ " # Get the output\n",
+ " log_ps = model(images)\n",
+ " # Get the loss\n",
+ " testLoss += criterion(log_ps, labels)\n",
+ " \n",
+ " # Get the probabilities\n",
+ " ps = torch.exp(log_ps)\n",
+ " # Get the most likely class for each prediction\n",
+ " top_p, top_class = ps.topk(1, dim=1)\n",
+ " # Check if the predictions match the actual label\n",
+ " equals = top_class == labels.view(*top_class.shape)\n",
+ " # Update accuracy\n",
+ " accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
+ " \n",
+ " # Update train loss\n",
+ " trainLosses.append(runningLoss/len(trainloader))\n",
+ " # Update test loss\n",
+ " testLosses.append(testLoss/len(testloader))\n",
+ " \n",
+ " # Set model back to train mode\n",
+ " model.train()\n",
+ " \n",
+ " # Print output\n",
+ " print(f'Epoch: {e+1} out of {epochs}')\n",
+ " print(f'Training Loss: {runningLoss/len(trainloader):.3f}')\n",
+ " print(f'Test Loss: {testLoss/len(testloader):.3f}')\n",
+ " print(f'Test Accuracy: {accuracy/len(testloader):.3f}')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 36,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 250,
+ "width": 380
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(trainLosses, label='Training loss')\n",
+ "plt.plot(testLosses, label='Validation loss')\n",
+ "plt.legend(frameon=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Inference\n",
+ "\n",
+ "Now that the model is trained, we can use it for inference. We've done this before, but now we need to remember to set the model in inference mode with `model.eval()`. You'll also want to turn off autograd with the `torch.no_grad()` context."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 44,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000,\n",
+ " 0.0000, 1.0000, 0.0000]])\n"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 204,
+ "width": 423
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Import helper module (should be in the repo)\n",
+ "import helper\n",
+ "\n",
+ "# Test out your network!\n",
+ "\n",
+ "model.eval()\n",
+ "\n",
+ "dataiter = iter(testloader)\n",
+ "images, labels = dataiter.next()\n",
+ "img = images[0]\n",
+ "# Convert 2D image to 1D vector\n",
+ "img = img.view(1, 784)\n",
+ "\n",
+ "# Calculate the class probabilities (softmax) for img\n",
+ "with torch.no_grad():\n",
+ " output = model.forward(img)\n",
+ "\n",
+ "ps = torch.exp(output)\n",
+ "\n",
+ "# Plot the image and probabilities\n",
+ "helper.view_classify(img.view(1, 28, 28), ps, version='Fashion')\n",
+ "\n",
+ "print(ps)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Next Up!\n",
+ "\n",
+ "In the next part, I'll show you how to save your trained models. In general, you won't want to train a model everytime you need it. Instead, you'll train once, save it, then load the model when you want to train more or use if for inference."
+ ]
+ }
+ ],
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 6 - Saving and Loading Models.ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 6 - Saving and Loading Models.ipynb
new file mode 100644
index 0000000..dca521e
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 6 - Saving and Loading Models.ipynb
@@ -0,0 +1,413 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Saving and Loading Models\n",
+ "\n",
+ "In this notebook, I'll show you how to save and load models with PyTorch. This is important because you'll often want to load previously trained models to use in making predictions or to continue training on new data."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import torch\n",
+ "from torch import nn\n",
+ "from torch import optim\n",
+ "import torch.nn.functional as F\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "import helper\n",
+ "import fc_model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n",
+ "Processing...\n",
+ "Done!\n"
+ ]
+ }
+ ],
+ "source": [
+ "# 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('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('F_MNIST_data/', download=True, train=False, transform=transform)\n",
+ "testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)"
+ ]
+ },
+ {
+ "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": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 233,
+ "width": 233
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "image, label = next(iter(trainloader))\n",
+ "helper.imshow(image[0,:]);"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Train a network\n",
+ "\n",
+ "To make things more concise here, I moved the model architecture and training code from the last part to a file called `fc_model`. Importing this, we can easily create a fully-connected network with `fc_model.Network`, and train the network using `fc_model.train`. I'll use this model (once it's trained) to demonstrate how we can save and load models."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Create the network, define the criterion and optimizer\n",
+ "\n",
+ "model = fc_model.Network(784, 10, [512, 256, 128])\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.Adam(model.parameters(), lr=0.001)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 1/2.. Training Loss: 1.710.. Test Loss: 0.976.. Test Accuracy: 0.679\n",
+ "Epoch: 1/2.. Training Loss: 1.043.. Test Loss: 0.760.. Test Accuracy: 0.713\n",
+ "Epoch: 1/2.. Training Loss: 0.864.. Test Loss: 0.675.. Test Accuracy: 0.737\n",
+ "Epoch: 1/2.. Training Loss: 0.780.. Test Loss: 0.635.. Test Accuracy: 0.749\n",
+ "Epoch: 1/2.. Training Loss: 0.787.. Test Loss: 0.617.. Test Accuracy: 0.770\n",
+ "Epoch: 1/2.. Training Loss: 0.755.. Test Loss: 0.590.. Test Accuracy: 0.774\n",
+ "Epoch: 1/2.. Training Loss: 0.717.. Test Loss: 0.583.. Test Accuracy: 0.773\n",
+ "Epoch: 1/2.. Training Loss: 0.650.. Test Loss: 0.565.. Test Accuracy: 0.778\n",
+ "Epoch: 1/2.. Training Loss: 0.661.. Test Loss: 0.561.. Test Accuracy: 0.790\n",
+ "Epoch: 1/2.. Training Loss: 0.637.. Test Loss: 0.560.. Test Accuracy: 0.796\n",
+ "Epoch: 1/2.. Training Loss: 0.586.. Test Loss: 0.529.. Test Accuracy: 0.799\n",
+ "Epoch: 1/2.. Training Loss: 0.627.. Test Loss: 0.525.. Test Accuracy: 0.805\n",
+ "Epoch: 1/2.. Training Loss: 0.602.. Test Loss: 0.521.. Test Accuracy: 0.809\n",
+ "Epoch: 1/2.. Training Loss: 0.635.. Test Loss: 0.522.. Test Accuracy: 0.810\n",
+ "Epoch: 1/2.. Training Loss: 0.606.. Test Loss: 0.502.. Test Accuracy: 0.810\n",
+ "Epoch: 1/2.. Training Loss: 0.582.. Test Loss: 0.522.. Test Accuracy: 0.805\n",
+ "Epoch: 1/2.. Training Loss: 0.584.. Test Loss: 0.507.. Test Accuracy: 0.822\n",
+ "Epoch: 1/2.. Training Loss: 0.545.. Test Loss: 0.500.. Test Accuracy: 0.818\n",
+ "Epoch: 1/2.. Training Loss: 0.599.. Test Loss: 0.489.. Test Accuracy: 0.826\n",
+ "Epoch: 1/2.. Training Loss: 0.585.. Test Loss: 0.498.. Test Accuracy: 0.816\n",
+ "Epoch: 1/2.. Training Loss: 0.546.. Test Loss: 0.482.. Test Accuracy: 0.821\n",
+ "Epoch: 1/2.. Training Loss: 0.527.. Test Loss: 0.477.. Test Accuracy: 0.828\n",
+ "Epoch: 1/2.. Training Loss: 0.563.. Test Loss: 0.482.. Test Accuracy: 0.820\n",
+ "Epoch: 2/2.. Training Loss: 0.558.. Test Loss: 0.473.. Test Accuracy: 0.830\n",
+ "Epoch: 2/2.. Training Loss: 0.525.. Test Loss: 0.492.. Test Accuracy: 0.821\n",
+ "Epoch: 2/2.. Training Loss: 0.534.. Test Loss: 0.469.. Test Accuracy: 0.830\n",
+ "Epoch: 2/2.. Training Loss: 0.548.. Test Loss: 0.483.. Test Accuracy: 0.827\n",
+ "Epoch: 2/2.. Training Loss: 0.559.. Test Loss: 0.471.. Test Accuracy: 0.825\n",
+ "Epoch: 2/2.. Training Loss: 0.534.. Test Loss: 0.469.. Test Accuracy: 0.831\n",
+ "Epoch: 2/2.. Training Loss: 0.568.. Test Loss: 0.473.. Test Accuracy: 0.823\n",
+ "Epoch: 2/2.. Training Loss: 0.551.. Test Loss: 0.463.. Test Accuracy: 0.829\n",
+ "Epoch: 2/2.. Training Loss: 0.566.. Test Loss: 0.453.. Test Accuracy: 0.832\n",
+ "Epoch: 2/2.. Training Loss: 0.513.. Test Loss: 0.446.. Test Accuracy: 0.835\n",
+ "Epoch: 2/2.. Training Loss: 0.572.. Test Loss: 0.476.. Test Accuracy: 0.821\n",
+ "Epoch: 2/2.. Training Loss: 0.511.. Test Loss: 0.447.. Test Accuracy: 0.833\n",
+ "Epoch: 2/2.. Training Loss: 0.554.. Test Loss: 0.449.. Test Accuracy: 0.833\n",
+ "Epoch: 2/2.. Training Loss: 0.502.. Test Loss: 0.468.. Test Accuracy: 0.832\n",
+ "Epoch: 2/2.. Training Loss: 0.507.. Test Loss: 0.451.. Test Accuracy: 0.834\n",
+ "Epoch: 2/2.. Training Loss: 0.502.. Test Loss: 0.454.. Test Accuracy: 0.840\n",
+ "Epoch: 2/2.. Training Loss: 0.536.. Test Loss: 0.444.. Test Accuracy: 0.839\n",
+ "Epoch: 2/2.. Training Loss: 0.503.. Test Loss: 0.447.. Test Accuracy: 0.837\n",
+ "Epoch: 2/2.. Training Loss: 0.542.. Test Loss: 0.446.. Test Accuracy: 0.840\n",
+ "Epoch: 2/2.. Training Loss: 0.549.. Test Loss: 0.438.. Test Accuracy: 0.838\n",
+ "Epoch: 2/2.. Training Loss: 0.510.. Test Loss: 0.461.. Test Accuracy: 0.830\n",
+ "Epoch: 2/2.. Training Loss: 0.544.. Test Loss: 0.448.. Test Accuracy: 0.837\n",
+ "Epoch: 2/2.. Training Loss: 0.496.. Test Loss: 0.448.. Test Accuracy: 0.843\n"
+ ]
+ }
+ ],
+ "source": [
+ "fc_model.train(model, trainloader, testloader, criterion, optimizer, epochs=2)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Saving and loading networks\n",
+ "\n",
+ "As you can imagine, it's impractical to train a network every time you need to use it. Instead, we can save trained networks then load them later to train more or use them for predictions.\n",
+ "\n",
+ "The parameters for PyTorch networks are stored in a model's `state_dict`. We can see the state dict contains the weight and bias matrices for each of our layers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Our model: \n",
+ "\n",
+ " Network(\n",
+ " (hidden_layers): ModuleList(\n",
+ " (0): Linear(in_features=784, out_features=512, bias=True)\n",
+ " (1): Linear(in_features=512, out_features=256, bias=True)\n",
+ " (2): Linear(in_features=256, out_features=128, bias=True)\n",
+ " )\n",
+ " (output): Linear(in_features=128, out_features=10, bias=True)\n",
+ " (dropout): Dropout(p=0.5)\n",
+ ") \n",
+ "\n",
+ "The state dict keys: \n",
+ "\n",
+ " odict_keys(['hidden_layers.0.weight', 'hidden_layers.0.bias', 'hidden_layers.1.weight', 'hidden_layers.1.bias', 'hidden_layers.2.weight', 'hidden_layers.2.bias', 'output.weight', 'output.bias'])\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Our model: \\n\\n\", model, '\\n')\n",
+ "print(\"The state dict keys: \\n\\n\", model.state_dict().keys())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The simplest thing to do is simply save the state dict with `torch.save`. For example, we can save it to a file `'checkpoint.pth'`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "torch.save(model.state_dict(), 'checkpoint.pth')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Then we can load the state dict with `torch.load`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "odict_keys(['hidden_layers.0.weight', 'hidden_layers.0.bias', 'hidden_layers.1.weight', 'hidden_layers.1.bias', 'hidden_layers.2.weight', 'hidden_layers.2.bias', 'output.weight', 'output.bias'])\n"
+ ]
+ }
+ ],
+ "source": [
+ "state_dict = torch.load('checkpoint.pth')\n",
+ "print(state_dict.keys())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "And to load the state dict in to the network, you do `model.load_state_dict(state_dict)`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "model.load_state_dict(state_dict)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Seems pretty straightforward, but as usual it's a bit more complicated. Loading the state dict works only if the model architecture is exactly the same as the checkpoint architecture. If I create a model with a different architecture, this fails."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [
+ {
+ "ename": "RuntimeError",
+ "evalue": "Error(s) in loading state_dict for Network:\n\tWhile copying the parameter named \"hidden_layers.0.weight\", whose dimensions in the model are torch.Size([400, 784]) and whose dimensions in the checkpoint are torch.Size([512, 784]).\n\tWhile copying the parameter named \"hidden_layers.0.bias\", whose dimensions in the model are torch.Size([400]) and whose dimensions in the checkpoint are torch.Size([512]).\n\tWhile copying the parameter named \"hidden_layers.1.weight\", whose dimensions in the model are torch.Size([200, 400]) and whose dimensions in the checkpoint are torch.Size([256, 512]).\n\tWhile copying the parameter named \"hidden_layers.1.bias\", whose dimensions in the model are torch.Size([200]) and whose dimensions in the checkpoint are torch.Size([256]).\n\tWhile copying the parameter named \"hidden_layers.2.weight\", whose dimensions in the model are torch.Size([100, 200]) and whose dimensions in the checkpoint are torch.Size([128, 256]).\n\tWhile copying the parameter named \"hidden_layers.2.bias\", whose dimensions in the model are torch.Size([100]) and whose dimensions in the checkpoint are torch.Size([128]).\n\tWhile copying the parameter named \"output.weight\", whose dimensions in the model are torch.Size([10, 100]) and whose dimensions in the checkpoint are torch.Size([10, 128]).",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mRuntimeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mmodel\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfc_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNetwork\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m784\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m400\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m200\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;31m# This will throw an error because the tensor sizes are wrong!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_state_dict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate_dict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+ "\u001b[0;32m/opt/conda/lib/python3.6/site-packages/torch/nn/modules/module.py\u001b[0m in \u001b[0;36mload_state_dict\u001b[0;34m(self, state_dict, strict)\u001b[0m\n\u001b[1;32m 719\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0merror_msgs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 720\u001b[0m raise RuntimeError('Error(s) in loading state_dict for {}:\\n\\t{}'.format(\n\u001b[0;32m--> 721\u001b[0;31m self.__class__.__name__, \"\\n\\t\".join(error_msgs)))\n\u001b[0m\u001b[1;32m 722\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 723\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mparameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mRuntimeError\u001b[0m: Error(s) in loading state_dict for Network:\n\tWhile copying the parameter named \"hidden_layers.0.weight\", whose dimensions in the model are torch.Size([400, 784]) and whose dimensions in the checkpoint are torch.Size([512, 784]).\n\tWhile copying the parameter named \"hidden_layers.0.bias\", whose dimensions in the model are torch.Size([400]) and whose dimensions in the checkpoint are torch.Size([512]).\n\tWhile copying the parameter named \"hidden_layers.1.weight\", whose dimensions in the model are torch.Size([200, 400]) and whose dimensions in the checkpoint are torch.Size([256, 512]).\n\tWhile copying the parameter named \"hidden_layers.1.bias\", whose dimensions in the model are torch.Size([200]) and whose dimensions in the checkpoint are torch.Size([256]).\n\tWhile copying the parameter named \"hidden_layers.2.weight\", whose dimensions in the model are torch.Size([100, 200]) and whose dimensions in the checkpoint are torch.Size([128, 256]).\n\tWhile copying the parameter named \"hidden_layers.2.bias\", whose dimensions in the model are torch.Size([100]) and whose dimensions in the checkpoint are torch.Size([128]).\n\tWhile copying the parameter named \"output.weight\", whose dimensions in the model are torch.Size([10, 100]) and whose dimensions in the checkpoint are torch.Size([10, 128])."
+ ]
+ }
+ ],
+ "source": [
+ "# Try this\n",
+ "model = fc_model.Network(784, 10, [400, 200, 100])\n",
+ "# This will throw an error because the tensor sizes are wrong!\n",
+ "model.load_state_dict(state_dict)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This means we need to rebuild the model exactly as it was when trained. Information about the model architecture needs to be saved in the checkpoint, along with the state dict. To do this, you build a dictionary with all the information you need to compeletely rebuild the model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "checkpoint = {'input_size': 784,\n",
+ " 'output_size': 10,\n",
+ " 'hidden_layers': [each.out_features for each in model.hidden_layers],\n",
+ " 'state_dict': model.state_dict()}\n",
+ "\n",
+ "torch.save(checkpoint, 'checkpoint.pth')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now the checkpoint has all the necessary information to rebuild the trained model. You can easily make that a function if you want. Similarly, we can write a function to load checkpoints. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def load_checkpoint(filepath):\n",
+ " checkpoint = torch.load(filepath)\n",
+ " model = fc_model.Network(checkpoint['input_size'],\n",
+ " checkpoint['output_size'],\n",
+ " checkpoint['hidden_layers'])\n",
+ " model.load_state_dict(checkpoint['state_dict'])\n",
+ " \n",
+ " return model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Network(\n",
+ " (hidden_layers): ModuleList(\n",
+ " (0): Linear(in_features=784, out_features=400, bias=True)\n",
+ " (1): Linear(in_features=400, out_features=200, bias=True)\n",
+ " (2): Linear(in_features=200, out_features=100, bias=True)\n",
+ " )\n",
+ " (output): Linear(in_features=100, out_features=10, bias=True)\n",
+ " (dropout): Dropout(p=0.5)\n",
+ ")\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = load_checkpoint('checkpoint.pth')\n",
+ "print(model)"
+ ]
+ },
+ {
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 7 - Loading Image Data (Exercises).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 7 - Loading Image Data (Exercises).ipynb
new file mode 100644
index 0000000..234adcc
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 7 - Loading Image Data (Exercises).ipynb
@@ -0,0 +1,299 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Loading Image Data\n",
+ "\n",
+ "So far we've been working with fairly artificial datasets that you wouldn't typically be using in real projects. Instead, you'll likely be dealing with full-sized images like you'd get from smart phone cameras. In this notebook, we'll look at how to load images and use them to train neural networks.\n",
+ "\n",
+ "We'll be using a [dataset of cat and dog photos](https://www.kaggle.com/c/dogs-vs-cats) available from Kaggle. Here are a couple example images:\n",
+ "\n",
+ "\n",
+ "\n",
+ "We'll use this dataset to train a neural network that can differentiate between cats and dogs. These days it doesn't seem like a big accomplishment, but five years ago it was a serious challenge for computer vision systems."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import torch\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "import helper"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The easiest way to load image data is with `datasets.ImageFolder` from `torchvision` ([documentation](http://pytorch.org/docs/master/torchvision/datasets.html#imagefolder)). In general you'll use `ImageFolder` like so:\n",
+ "\n",
+ "```python\n",
+ "dataset = datasets.ImageFolder('path/to/data', transform=transform)\n",
+ "```\n",
+ "\n",
+ "where `'path/to/data'` is the file path to the data directory and `transform` is a list of processing steps built with the [`transforms`](http://pytorch.org/docs/master/torchvision/transforms.html) module from `torchvision`. ImageFolder expects the files and directories to be constructed like so:\n",
+ "```\n",
+ "root/dog/xxx.png\n",
+ "root/dog/xxy.png\n",
+ "root/dog/xxz.png\n",
+ "\n",
+ "root/cat/123.png\n",
+ "root/cat/nsdf3.png\n",
+ "root/cat/asd932_.png\n",
+ "```\n",
+ "\n",
+ "where each class has it's own directory (`cat` and `dog`) for the images. The images are then labeled with the class taken from the directory name. So here, the image `123.png` would be loaded with the class label `cat`. You can download the dataset already structured like this [from here](https://s3.amazonaws.com/content.udacity-data.com/nd089/Cat_Dog_data.zip). I've also split it into a training set and test set.\n",
+ "\n",
+ "### Transforms\n",
+ "\n",
+ "When you load in the data with `ImageFolder`, you'll need to define some transforms. For example, the images are different sizes but we'll need them to all be the same size for training. You can either resize them with `transforms.Resize()` or crop with `transforms.CenterCrop()`, `transforms.RandomResizedCrop()`, etc. We'll also need to convert the images to PyTorch tensors with `transforms.ToTensor()`. Typically you'll combine these transforms into a pipeline with `transforms.Compose()`, which accepts a list of transforms and runs them in sequence. It looks something like this to scale, then crop, then convert to a tensor:\n",
+ "\n",
+ "```python\n",
+ "transform = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor()])\n",
+ "\n",
+ "```\n",
+ "\n",
+ "There are plenty of transforms available, I'll cover more in a bit and you can read through the [documentation](http://pytorch.org/docs/master/torchvision/transforms.html). \n",
+ "\n",
+ "### Data Loaders\n",
+ "\n",
+ "With the `ImageFolder` loaded, you have to pass it to a [`DataLoader`](http://pytorch.org/docs/master/data.html#torch.utils.data.DataLoader). The `DataLoader` takes a dataset (such as you would get from `ImageFolder`) and returns batches of images and the corresponding labels. You can set various parameters like the batch size and if the data is shuffled after each epoch.\n",
+ "\n",
+ "```python\n",
+ "dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)\n",
+ "```\n",
+ "\n",
+ "Here `dataloader` is a [generator](https://jeffknupp.com/blog/2013/04/07/improve-your-python-yield-and-generators-explained/). To get data out of it, you need to loop through it or convert it to an iterator and call `next()`.\n",
+ "\n",
+ "```python\n",
+ "# Looping through it, get a batch on each loop \n",
+ "for images, labels in dataloader:\n",
+ " pass\n",
+ "\n",
+ "# Get one batch\n",
+ "images, labels = next(iter(dataloader))\n",
+ "```\n",
+ " \n",
+ ">**Exercise:** Load images from the `Cat_Dog_data/train` folder, define a few transforms, then build the dataloader."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_dir = 'Cat_Dog_data/train'\n",
+ "\n",
+ "transform = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor()])\n",
+ "dataset = datasets.ImageFolder(data_dir, transform=transform)\n",
+ "dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 233,
+ "width": 233
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Run this to test your data loader\n",
+ "images, labels = next(iter(dataloader))\n",
+ "helper.imshow(images[0], normalize=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If you loaded the data correctly, you should see something like this (your image will be different):\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Data Augmentation\n",
+ "\n",
+ "A common strategy for training neural networks is to introduce randomness in the input data itself. For example, you can randomly rotate, mirror, scale, and/or crop your images during training. This will help your network generalize as it's seeing the same images but in different locations, with different sizes, in different orientations, etc.\n",
+ "\n",
+ "To randomly rotate, scale and crop, then flip your images you would define your transforms like this:\n",
+ "\n",
+ "```python\n",
+ "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n",
+ " transforms.RandomResizedCrop(224),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.5, 0.5, 0.5], \n",
+ " [0.5, 0.5, 0.5])])\n",
+ "```\n",
+ "\n",
+ "You'll also typically want to normalize images with `transforms.Normalize`. You pass in a list of means and list of standard deviations, then the color channels are normalized like so\n",
+ "\n",
+ "```input[channel] = (input[channel] - mean[channel]) / std[channel]```\n",
+ "\n",
+ "Subtracting `mean` centers the data around zero and dividing by `std` squishes the values to be between -1 and 1. Normalizing helps keep the network work weights near zero which in turn makes backpropagation more stable. Without normalization, networks will tend to fail to learn.\n",
+ "\n",
+ "You can find a list of all [the available transforms here](http://pytorch.org/docs/0.3.0/torchvision/transforms.html). When you're testing however, you'll want to use images that aren't altered (except you'll need to normalize the same way). So, for validation/test images, you'll typically just resize and crop.\n",
+ "\n",
+ ">**Exercise:** Define transforms for training data and testing data below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_dir = 'Cat_Dog_data'\n",
+ "\n",
+ "# TODO: Define transforms for the training data and testing data\n",
+ "# TODO: Define transforms for the training data and testing data\n",
+ "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n",
+ " transforms.RandomResizedCrop(224),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor()]) \n",
+ "\n",
+ "test_transforms = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor()])\n",
+ "\n",
+ "\n",
+ "# Pass transforms in here, then run the next cell to see how the transforms look\n",
+ "train_data = datasets.ImageFolder(data_dir + '/train', transform=train_transforms)\n",
+ "test_data = datasets.ImageFolder(data_dir + '/test', transform=test_transforms)\n",
+ "\n",
+ "trainloader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True)\n",
+ "testloader = torch.utils.data.DataLoader(test_data, batch_size=32)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "image/png": {
+ "height": 137,
+ "width": 574
+ },
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# change this to the trainloader or testloader \n",
+ "data_iter = iter(trainloader)\n",
+ "\n",
+ "images, labels = next(data_iter)\n",
+ "fig, axes = plt.subplots(figsize=(10,4), ncols=4)\n",
+ "for ii in range(4):\n",
+ " ax = axes[ii]\n",
+ " helper.imshow(images[ii], ax=ax, normalize=False)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Your transformed images should look something like this.\n",
+ "\n",
+ "
Training examples:
\n",
+ "\n",
+ "\n",
+ "
Testing examples:
\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "At this point you should be able to load data for training and testing. Now, you should try building a network that can classify cats vs dogs. This is quite a bit more complicated than before with the MNIST and Fashion-MNIST datasets. To be honest, you probably won't get it to work with a fully-connected network, no matter how deep. These images have three color channels and at a higher resolution (so far you've seen 28x28 images which are tiny).\n",
+ "\n",
+ "In the next part, I'll show you how to use a pre-trained network to build a model that can actually solve this problem."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Optional TODO: Attempt to build a network to classify cats vs dogs from this dataset"
+ ]
+ }
+ ],
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Exercises).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Exercises).ipynb
new file mode 100644
index 0000000..7ecb3a5
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Exercises).ipynb
@@ -0,0 +1,903 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Transfer Learning\n",
+ "\n",
+ "In this notebook, you'll learn how to use pre-trained networks to solved challenging problems in computer vision. Specifically, you'll use networks trained on [ImageNet](http://www.image-net.org/) [available from torchvision](http://pytorch.org/docs/0.3.0/torchvision/models.html). \n",
+ "\n",
+ "ImageNet is a massive dataset with over 1 million labeled images in 1000 categories. It's used to train deep neural networks using an architecture called convolutional layers. I'm not going to get into the details of convolutional networks here, but if you want to learn more about them, please [watch this](https://www.youtube.com/watch?v=2-Ol7ZB0MmU).\n",
+ "\n",
+ "Once trained, these models work astonishingly well as feature detectors for images they weren't trained on. Using a pre-trained network on images not in the training set is called transfer learning. Here we'll use transfer learning to train a network that can classify our cat and dog photos with near perfect accuracy.\n",
+ "\n",
+ "With `torchvision.models` you can download these pre-trained networks and use them in your applications. We'll include `models` in our imports now."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import torch\n",
+ "from torch import nn\n",
+ "from torch import optim\n",
+ "import torch.nn.functional as F\n",
+ "from torchvision import datasets, transforms, models"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Most of the pretrained models require the input to be 224x224 images. Also, we'll need to match the normalization used when the models were trained. Each color channel was normalized separately, the means are `[0.485, 0.456, 0.406]` and the standard deviations are `[0.229, 0.224, 0.225]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_dir = 'Cat_Dog_data'\n",
+ "\n",
+ "# TODO: Define transforms for the training data and testing data\n",
+ "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n",
+ " transforms.RandomResizedCrop(224),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406],\n",
+ " [0.229, 0.224, 0.225])])\n",
+ "\n",
+ "test_transforms = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406],\n",
+ " [0.229, 0.224, 0.225])])\n",
+ "\n",
+ "# Pass transforms in here, then run the next cell to see how the transforms look\n",
+ "train_data = datasets.ImageFolder(data_dir + '/train', transform=train_transforms)\n",
+ "test_data = datasets.ImageFolder(data_dir + '/test', transform=test_transforms)\n",
+ "\n",
+ "trainloader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)\n",
+ "testloader = torch.utils.data.DataLoader(test_data, batch_size=64)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can load in a model such as [DenseNet](http://pytorch.org/docs/0.3.0/torchvision/models.html#id5). Let's print out the model architecture so we can see what's going on."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/conda/lib/python3.6/site-packages/torchvision-0.2.1-py3.6.egg/torchvision/models/densenet.py:212: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "DenseNet(\n",
+ " (features): Sequential(\n",
+ " (conv0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+ " (norm0): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu0): ReLU(inplace)\n",
+ " (pool0): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+ " (denseblock1): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(96, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition1): _Transition(\n",
+ " (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock2): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition2): _Transition(\n",
+ " (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock3): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer13): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer14): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer15): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer16): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer17): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer18): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer19): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer20): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer21): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer22): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer23): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer24): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition3): _Transition(\n",
+ " (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock4): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer13): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer14): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer15): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer16): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (norm5): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " (classifier): Linear(in_features=1024, out_features=1000, bias=True)\n",
+ ")"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model = models.densenet121(pretrained=True)\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This model is built out of two main parts, the features and the classifier. The features part is a stack of convolutional layers and overall works as a feature detector that can be fed into a classifier. The classifier part is a single fully-connected layer `(classifier): Linear(in_features=1024, out_features=1000)`. This layer was trained on the ImageNet dataset, so it won't work for our specific problem. That means we need to replace the classifier, but the features will work perfectly on their own. In general, I think about pre-trained networks as amazingly good feature detectors that can be used as the input for simple feed-forward classifiers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Freeze parameters so we don't backprop through them\n",
+ "for param in model.parameters():\n",
+ " param.requires_grad = False\n",
+ "\n",
+ "from collections import OrderedDict\n",
+ "classifier = nn.Sequential(OrderedDict([\n",
+ " ('fc1', nn.Linear(1024, 500)),\n",
+ " ('relu', nn.ReLU()),\n",
+ " ('fc2', nn.Linear(500, 2)),\n",
+ " ('output', nn.LogSoftmax(dim=1))\n",
+ " ]))\n",
+ " \n",
+ "model.classifier = classifier"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "With our model built, we need to train the classifier. However, now we're using a **really deep** neural network. If you try to train this on a CPU like normal, it will take a long, long time. Instead, we're going to use the GPU to do the calculations. The linear algebra computations are done in parallel on the GPU leading to 100x increased training speeds. It's also possible to train on multiple GPUs, further decreasing training time.\n",
+ "\n",
+ "PyTorch, along with pretty much every other deep learning framework, uses [CUDA](https://developer.nvidia.com/cuda-zone) to efficiently compute the forward and backwards passes on the GPU. In PyTorch, you move your model parameters and other tensors to the GPU memory using `model.to('cuda')`. You can move them back from the GPU with `model.to('cpu')` which you'll commonly do when you need to operate on the network output outside of PyTorch. As a demonstration of the increased speed, I'll compare how long it takes to perform a forward and backward pass with and without a GPU."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Device = cpu; Time per batch: 5.701 seconds\n",
+ "Device = cuda; Time per batch: 0.010 seconds\n"
+ ]
+ }
+ ],
+ "source": [
+ "for device in ['cpu', 'cuda']:\n",
+ "\n",
+ " criterion = nn.NLLLoss()\n",
+ " # Only train the classifier parameters, feature parameters are frozen\n",
+ " optimizer = optim.Adam(model.classifier.parameters(), lr=0.001)\n",
+ "\n",
+ " model.to(device)\n",
+ "\n",
+ " for ii, (inputs, labels) in enumerate(trainloader):\n",
+ "\n",
+ " # Move input and label tensors to the GPU\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ "\n",
+ " start = time.time()\n",
+ "\n",
+ " outputs = model.forward(inputs)\n",
+ " loss = criterion(outputs, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " if ii==3:\n",
+ " break\n",
+ " \n",
+ " print(f\"Device = {device}; Time per batch: {(time.time() - start)/3:.3f} seconds\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can write device agnostic code which will automatically use CUDA if it's enabled like so:\n",
+ "```python\n",
+ "# at beginning of the script\n",
+ "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+ "\n",
+ "...\n",
+ "\n",
+ "# then whenever you get a new Tensor or Module\n",
+ "# this won't copy if they are already on the desired device\n",
+ "input = data.to(device)\n",
+ "model = MyModule(...).to(device)\n",
+ "```\n",
+ "\n",
+ "From here, I'll let you finish training the model. The process is the same as before except now your model is much more powerful. You should get better than 95% accuracy easily.\n",
+ "\n",
+ ">**Exercise:** Train a pretrained models to classify the cat and dog images. Continue with the DenseNet model, or try ResNet, it's also a good model to try out first. Make sure you are only training the classifier and the parameters for the features part are frozen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/conda/lib/python3.6/site-packages/torchvision-0.2.1-py3.6.egg/torchvision/models/densenet.py:212: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "device(type='cuda')"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "## TODO: Use a pretrained model to classify the cat and dog images\n",
+ "\n",
+ "# Use GPU if it's available\n",
+ "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+ "\n",
+ "model = models.densenet121(pretrained=True)\n",
+ "\n",
+ "# Freeze Parameters so we don't back propagate through them\n",
+ "for param in model.parameters():\n",
+ " param.requires_grad = False\n",
+ " \n",
+ "model.classifier = nn.Sequential(nn.Linear(1024, 256),\n",
+ " nn.ReLU(),\n",
+ " nn.Dropout(0.2),\n",
+ " nn.Linear(256, 2),\n",
+ " nn.LogSoftmax(dim=1))\n",
+ "\n",
+ "criterion = nn.NLLLoss()\n",
+ "\n",
+ "# Only train the classifier parameters, feature parameters are frozen\n",
+ "optimizer = optim.Adam(model.classifier.parameters(), lr=0.003)\n",
+ "\n",
+ "model.to(device)\n",
+ "device"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 1 out of 1\n",
+ "Training Loss: 0.208\n",
+ "Test Loss: 0.076\n",
+ "Test Accuracy: 0.971\n",
+ "\n",
+ "Epoch: 1 out of 1\n",
+ "Training Loss: 0.214\n",
+ "Test Loss: 0.068\n",
+ "Test Accuracy: 0.978\n",
+ "\n",
+ "Epoch: 1 out of 1\n",
+ "Training Loss: 0.216\n",
+ "Test Loss: 0.075\n",
+ "Test Accuracy: 0.971\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "epochs = 1\n",
+ "steps = 0\n",
+ "runningLoss = 0\n",
+ "printEvery = 5\n",
+ "\n",
+ "for epoch in range(epochs):\n",
+ " for inputs, labels in trainloader:\n",
+ " steps += 1\n",
+ " \n",
+ " # Move input and label tensors to the device\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ " \n",
+ " # Zero the gradients\n",
+ " optimizer.zero_grad()\n",
+ " \n",
+ " # Make forward pass\n",
+ " logps = model.forward(inputs)\n",
+ " \n",
+ " # Calculate loss\n",
+ " loss = criterion(logps, labels)\n",
+ " \n",
+ " # Backpropagate\n",
+ " loss.backward()\n",
+ " \n",
+ " # Update the weights\n",
+ " optimizer.step()\n",
+ " \n",
+ " runningLoss += loss.item()\n",
+ " \n",
+ " # Do the validation pass\n",
+ " if steps % printEvery == 0:\n",
+ " testLoss = 0\n",
+ " accuracy = 0\n",
+ " model.eval()\n",
+ " \n",
+ " with torch.no_grad():\n",
+ " for inputs, labels in testloader:\n",
+ " # Move input and label tensors to the device\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ " \n",
+ " # Get the output\n",
+ " logps = model.forward(inputs)\n",
+ " \n",
+ " # Get the loss\n",
+ " batchLoss = criterion(logps, labels)\n",
+ " testLoss += batchLoss.item()\n",
+ " \n",
+ " # Find the accuracy\n",
+ " # Get the probabilities\n",
+ " ps = torch.exp(logps)\n",
+ " \n",
+ " # Get the most likely class for each prediction\n",
+ " top_p, top_class = ps.topk(1, dim=1)\n",
+ " \n",
+ " # Check if the predictions match the actual label\n",
+ " equals = top_class == labels.view(*top_class.shape)\n",
+ " \n",
+ " # Update accuracy\n",
+ " accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
+ " \n",
+ " # Print output\n",
+ " print(f'Epoch: {epoch+1} out of {epochs}')\n",
+ " print(f'Training Loss: {runningLoss/printEvery:.3f}')\n",
+ " print(f'Test Loss: {testLoss/len(testloader):.3f}')\n",
+ " print(f'Test Accuracy: {accuracy/len(testloader):.3f}')\n",
+ " print()\n",
+ "\n",
+ " runningLoss = 0\n",
+ " model.train()"
+ ]
+ },
+ {
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Solution).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Solution).ipynb
new file mode 100644
index 0000000..fe32747
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Solution).ipynb
@@ -0,0 +1,861 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Transfer Learning\n",
+ "\n",
+ "In this notebook, you'll learn how to use pre-trained networks to solved challenging problems in computer vision. Specifically, you'll use networks trained on [ImageNet](http://www.image-net.org/) [available from torchvision](http://pytorch.org/docs/0.3.0/torchvision/models.html). \n",
+ "\n",
+ "ImageNet is a massive dataset with over 1 million labeled images in 1000 categories. It's used to train deep neural networks using an architecture called convolutional layers. I'm not going to get into the details of convolutional networks here, but if you want to learn more about them, please [watch this](https://www.youtube.com/watch?v=2-Ol7ZB0MmU).\n",
+ "\n",
+ "Once trained, these models work astonishingly well as feature detectors for images they weren't trained on. Using a pre-trained network on images not in the training set is called transfer learning. Here we'll use transfer learning to train a network that can classify our cat and dog photos with near perfect accuracy.\n",
+ "\n",
+ "With `torchvision.models` you can download these pre-trained networks and use them in your applications. We'll include `models` in our imports now."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import torch\n",
+ "from torch import nn\n",
+ "from torch import optim\n",
+ "import torch.nn.functional as F\n",
+ "from torchvision import datasets, transforms, models"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Most of the pretrained models require the input to be 224x224 images. Also, we'll need to match the normalization used when the models were trained. Each color channel was normalized separately, the means are `[0.485, 0.456, 0.406]` and the standard deviations are `[0.229, 0.224, 0.225]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_dir = 'Cat_Dog_data'\n",
+ "\n",
+ "# TODO: Define transforms for the training data and testing data\n",
+ "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n",
+ " transforms.RandomResizedCrop(224),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406],\n",
+ " [0.229, 0.224, 0.225])])\n",
+ "\n",
+ "test_transforms = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406],\n",
+ " [0.229, 0.224, 0.225])])\n",
+ "\n",
+ "# Pass transforms in here, then run the next cell to see how the transforms look\n",
+ "train_data = datasets.ImageFolder(data_dir + '/train', transform=train_transforms)\n",
+ "test_data = datasets.ImageFolder(data_dir + '/test', transform=test_transforms)\n",
+ "\n",
+ "trainloader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)\n",
+ "testloader = torch.utils.data.DataLoader(test_data, batch_size=64)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can load in a model such as [DenseNet](http://pytorch.org/docs/0.3.0/torchvision/models.html#id5). Let's print out the model architecture so we can see what's going on."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/conda/lib/python3.6/site-packages/torchvision-0.2.1-py3.6.egg/torchvision/models/densenet.py:212: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "DenseNet(\n",
+ " (features): Sequential(\n",
+ " (conv0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+ " (norm0): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu0): ReLU(inplace)\n",
+ " (pool0): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+ " (denseblock1): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(96, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition1): _Transition(\n",
+ " (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock2): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition2): _Transition(\n",
+ " (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock3): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer13): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer14): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer15): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer16): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer17): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer18): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer19): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer20): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer21): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer22): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer23): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer24): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition3): _Transition(\n",
+ " (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock4): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer13): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer14): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer15): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer16): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (norm5): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " (classifier): Linear(in_features=1024, out_features=1000, bias=True)\n",
+ ")"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model = models.densenet121(pretrained=True)\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This model is built out of two main parts, the features and the classifier. The features part is a stack of convolutional layers and overall works as a feature detector that can be fed into a classifier. The classifier part is a single fully-connected layer `(classifier): Linear(in_features=1024, out_features=1000)`. This layer was trained on the ImageNet dataset, so it won't work for our specific problem. That means we need to replace the classifier, but the features will work perfectly on their own. In general, I think about pre-trained networks as amazingly good feature detectors that can be used as the input for simple feed-forward classifiers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Freeze parameters so we don't backprop through them\n",
+ "for param in model.parameters():\n",
+ " param.requires_grad = False\n",
+ "\n",
+ "from collections import OrderedDict\n",
+ "classifier = nn.Sequential(OrderedDict([\n",
+ " ('fc1', nn.Linear(1024, 500)),\n",
+ " ('relu', nn.ReLU()),\n",
+ " ('fc2', nn.Linear(500, 2)),\n",
+ " ('output', nn.LogSoftmax(dim=1))\n",
+ " ]))\n",
+ " \n",
+ "model.classifier = classifier"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "With our model built, we need to train the classifier. However, now we're using a **really deep** neural network. If you try to train this on a CPU like normal, it will take a long, long time. Instead, we're going to use the GPU to do the calculations. The linear algebra computations are done in parallel on the GPU leading to 100x increased training speeds. It's also possible to train on multiple GPUs, further decreasing training time.\n",
+ "\n",
+ "PyTorch, along with pretty much every other deep learning framework, uses [CUDA](https://developer.nvidia.com/cuda-zone) to efficiently compute the forward and backwards passes on the GPU. In PyTorch, you move your model parameters and other tensors to the GPU memory using `model.to('cuda')`. You can move them back from the GPU with `model.to('cpu')` which you'll commonly do when you need to operate on the network output outside of PyTorch. As a demonstration of the increased speed, I'll compare how long it takes to perform a forward and backward pass with and without a GPU."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Device = cpu; Time per batch: 5.634 seconds\n",
+ "Device = cuda; Time per batch: 0.010 seconds\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Try to replace with just ['cuda'] if you are using GPU \n",
+ "\n",
+ "for device in ['cpu', 'cuda']:\n",
+ "\n",
+ " criterion = nn.NLLLoss()\n",
+ " # Only train the classifier parameters, feature parameters are frozen\n",
+ " optimizer = optim.Adam(model.classifier.parameters(), lr=0.001)\n",
+ "\n",
+ " model.to(device)\n",
+ "\n",
+ " for ii, (inputs, labels) in enumerate(trainloader):\n",
+ "\n",
+ " # Move input and label tensors to the GPU\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ "\n",
+ " start = time.time()\n",
+ "\n",
+ " outputs = model.forward(inputs)\n",
+ " loss = criterion(outputs, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " if ii==3:\n",
+ " break\n",
+ " \n",
+ " print(f\"Device = {device}; Time per batch: {(time.time() - start)/3:.3f} seconds\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can write device agnostic code which will automatically use CUDA if it's enabled like so:\n",
+ "```python\n",
+ "# at beginning of the script\n",
+ "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+ "\n",
+ "...\n",
+ "\n",
+ "# then whenever you get a new Tensor or Module\n",
+ "# this won't copy if they are already on the desired device\n",
+ "input = data.to(device)\n",
+ "model = MyModule(...).to(device)\n",
+ "```\n",
+ "\n",
+ "From here, I'll let you finish training the model. The process is the same as before except now your model is much more powerful. You should get better than 95% accuracy easily.\n",
+ "\n",
+ ">**Exercise:** Train a pretrained models to classify the cat and dog images. Continue with the DenseNet model, or try ResNet, it's also a good model to try out first. Make sure you are only training the classifier and the parameters for the features part are frozen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/conda/lib/python3.6/site-packages/torchvision-0.2.1-py3.6.egg/torchvision/models/densenet.py:212: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Use GPU if it's available\n",
+ "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+ "\n",
+ "model = models.densenet121(pretrained=True)\n",
+ "\n",
+ "# Freeze parameters so we don't backprop through them\n",
+ "for param in model.parameters():\n",
+ " param.requires_grad = False\n",
+ " \n",
+ "model.classifier = nn.Sequential(nn.Linear(1024, 256),\n",
+ " nn.ReLU(),\n",
+ " nn.Dropout(0.2),\n",
+ " nn.Linear(256, 2),\n",
+ " nn.LogSoftmax(dim=1))\n",
+ "\n",
+ "criterion = nn.NLLLoss()\n",
+ "\n",
+ "# Only train the classifier parameters, feature parameters are frozen\n",
+ "optimizer = optim.Adam(model.classifier.parameters(), lr=0.003)\n",
+ "\n",
+ "model.to(device);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 1/1.. Train loss: 0.844.. Test loss: 0.479.. Test accuracy: 0.675\n",
+ "Epoch 1/1.. Train loss: 0.596.. Test loss: 0.331.. Test accuracy: 0.841\n",
+ "Epoch 1/1.. Train loss: 0.314.. Test loss: 0.183.. Test accuracy: 0.939\n",
+ "Epoch 1/1.. Train loss: 0.287.. Test loss: 0.108.. Test accuracy: 0.966\n",
+ "Epoch 1/1.. Train loss: 0.241.. Test loss: 0.091.. Test accuracy: 0.969\n",
+ "Epoch 1/1.. Train loss: 0.210.. Test loss: 0.111.. Test accuracy: 0.959\n",
+ "Epoch 1/1.. Train loss: 0.192.. Test loss: 0.083.. Test accuracy: 0.969\n",
+ "Epoch 1/1.. Train loss: 0.168.. Test loss: 0.076.. Test accuracy: 0.973\n",
+ "Epoch 1/1.. Train loss: 0.176.. Test loss: 0.060.. Test accuracy: 0.979\n",
+ "Epoch 1/1.. Train loss: 0.174.. Test loss: 0.087.. Test accuracy: 0.965\n",
+ "Epoch 1/1.. Train loss: 0.167.. Test loss: 0.100.. Test accuracy: 0.960\n",
+ "Epoch 1/1.. Train loss: 0.243.. Test loss: 0.052.. Test accuracy: 0.980\n",
+ "Epoch 1/1.. Train loss: 0.252.. Test loss: 0.054.. Test accuracy: 0.982\n",
+ "Epoch 1/1.. Train loss: 0.207.. Test loss: 0.054.. Test accuracy: 0.982\n",
+ "Epoch 1/1.. Train loss: 0.199.. Test loss: 0.068.. Test accuracy: 0.979\n",
+ "Epoch 1/1.. Train loss: 0.200.. Test loss: 0.085.. Test accuracy: 0.969\n",
+ "Epoch 1/1.. Train loss: 0.196.. Test loss: 0.052.. Test accuracy: 0.982\n"
+ ]
+ }
+ ],
+ "source": [
+ "epochs = 1\n",
+ "steps = 0\n",
+ "running_loss = 0\n",
+ "print_every = 5\n",
+ "for epoch in range(epochs):\n",
+ " for inputs, labels in trainloader:\n",
+ " steps += 1\n",
+ " # Move input and label tensors to the default device\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ " \n",
+ " optimizer.zero_grad()\n",
+ " \n",
+ " logps = model.forward(inputs)\n",
+ " loss = criterion(logps, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " running_loss += loss.item()\n",
+ " \n",
+ " if steps % print_every == 0:\n",
+ " test_loss = 0\n",
+ " accuracy = 0\n",
+ " model.eval()\n",
+ " with torch.no_grad():\n",
+ " for inputs, labels in testloader:\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ " logps = model.forward(inputs)\n",
+ " batch_loss = criterion(logps, labels)\n",
+ " \n",
+ " test_loss += batch_loss.item()\n",
+ " \n",
+ " # Calculate accuracy\n",
+ " ps = torch.exp(logps)\n",
+ " top_p, top_class = ps.topk(1, dim=1)\n",
+ " equals = top_class == labels.view(*top_class.shape)\n",
+ " accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
+ " \n",
+ " print(f\"Epoch {epoch+1}/{epochs}.. \"\n",
+ " f\"Train loss: {running_loss/print_every:.3f}.. \"\n",
+ " f\"Test loss: {test_loss/len(testloader):.3f}.. \"\n",
+ " f\"Test accuracy: {accuracy/len(testloader):.3f}\")\n",
+ " running_loss = 0\n",
+ " model.train()"
+ ]
+ },
+ {
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Untitled.ipynb b/python/Deep Learning/Deep Learning with PyTorch/Untitled.ipynb
new file mode 100644
index 0000000..08ec6ba
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Untitled.ipynb
@@ -0,0 +1,332 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "torch.Size([64, 10])\n",
+ "tensor([[9],\n",
+ " [9],\n",
+ " [9],\n",
+ " [9],\n",
+ " [9],\n",
+ " [5],\n",
+ " [9],\n",
+ " [5],\n",
+ " [2],\n",
+ " [9]])\n",
+ "Accuracy: 1.5625%\n",
+ "Epoch: 1 out of 30\n",
+ "Training Loss: 0.510\n",
+ "Test Loss: 0.454\n",
+ "Test Accuracy: 0.836\n",
+ "\n",
+ "Epoch: 2 out of 30\n",
+ "Training Loss: 0.389\n",
+ "Test Loss: 0.412\n",
+ "Test Accuracy: 0.852\n",
+ "\n",
+ "Epoch: 3 out of 30\n",
+ "Training Loss: 0.353\n",
+ "Test Loss: 0.388\n",
+ "Test Accuracy: 0.861\n",
+ "\n",
+ "Epoch: 4 out of 30\n",
+ "Training Loss: 0.330\n",
+ "Test Loss: 0.428\n",
+ "Test Accuracy: 0.847\n",
+ "\n",
+ "Epoch: 5 out of 30\n",
+ "Training Loss: 0.315\n",
+ "Test Loss: 0.381\n",
+ "Test Accuracy: 0.865\n",
+ "\n",
+ "Epoch: 6 out of 30\n",
+ "Training Loss: 0.303\n",
+ "Test Loss: 0.388\n",
+ "Test Accuracy: 0.864\n",
+ "\n",
+ "Epoch: 7 out of 30\n",
+ "Training Loss: 0.292\n",
+ "Test Loss: 0.364\n",
+ "Test Accuracy: 0.872\n",
+ "\n",
+ "Epoch: 8 out of 30\n",
+ "Training Loss: 0.281\n",
+ "Test Loss: 0.370\n",
+ "Test Accuracy: 0.869\n",
+ "\n",
+ "Epoch: 9 out of 30\n",
+ "Training Loss: 0.270\n",
+ "Test Loss: 0.365\n",
+ "Test Accuracy: 0.877\n",
+ "\n",
+ "Epoch: 10 out of 30\n",
+ "Training Loss: 0.267\n",
+ "Test Loss: 0.366\n",
+ "Test Accuracy: 0.877\n",
+ "\n",
+ "Epoch: 11 out of 30\n",
+ "Training Loss: 0.260\n",
+ "Test Loss: 0.369\n",
+ "Test Accuracy: 0.873\n",
+ "\n",
+ "Epoch: 12 out of 30\n",
+ "Training Loss: 0.254\n",
+ "Test Loss: 0.377\n",
+ "Test Accuracy: 0.876\n",
+ "\n",
+ "Epoch: 13 out of 30\n",
+ "Training Loss: 0.244\n",
+ "Test Loss: 0.369\n",
+ "Test Accuracy: 0.879\n",
+ "\n",
+ "Epoch: 14 out of 30\n",
+ "Training Loss: 0.243\n",
+ "Test Loss: 0.371\n",
+ "Test Accuracy: 0.879\n",
+ "\n",
+ "Epoch: 15 out of 30\n",
+ "Training Loss: 0.237\n",
+ "Test Loss: 0.377\n",
+ "Test Accuracy: 0.883\n",
+ "\n",
+ "Epoch: 16 out of 30\n",
+ "Training Loss: 0.230\n",
+ "Test Loss: 0.407\n",
+ "Test Accuracy: 0.874\n",
+ "\n",
+ "Epoch: 17 out of 30\n",
+ "Training Loss: 0.228\n",
+ "Test Loss: 0.370\n",
+ "Test Accuracy: 0.879\n",
+ "\n",
+ "Epoch: 18 out of 30\n",
+ "Training Loss: 0.221\n",
+ "Test Loss: 0.376\n",
+ "Test Accuracy: 0.878\n",
+ "\n",
+ "Epoch: 19 out of 30\n",
+ "Training Loss: 0.222\n",
+ "Test Loss: 0.376\n",
+ "Test Accuracy: 0.881\n",
+ "\n",
+ "Epoch: 20 out of 30\n",
+ "Training Loss: 0.217\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.880\n",
+ "\n",
+ "Epoch: 21 out of 30\n",
+ "Training Loss: 0.209\n",
+ "Test Loss: 0.401\n",
+ "Test Accuracy: 0.877\n",
+ "\n",
+ "Epoch: 22 out of 30\n",
+ "Training Loss: 0.210\n",
+ "Test Loss: 0.392\n",
+ "Test Accuracy: 0.883\n",
+ "\n",
+ "Epoch: 23 out of 30\n",
+ "Training Loss: 0.204\n",
+ "Test Loss: 0.411\n",
+ "Test Accuracy: 0.878\n",
+ "\n",
+ "Epoch: 24 out of 30\n",
+ "Training Loss: 0.202\n",
+ "Test Loss: 0.391\n",
+ "Test Accuracy: 0.882\n",
+ "\n",
+ "Epoch: 25 out of 30\n",
+ "Training Loss: 0.195\n",
+ "Test Loss: 0.392\n",
+ "Test Accuracy: 0.883\n",
+ "\n",
+ "Epoch: 26 out of 30\n",
+ "Training Loss: 0.195\n",
+ "Test Loss: 0.471\n",
+ "Test Accuracy: 0.878\n",
+ "\n",
+ "Epoch: 27 out of 30\n",
+ "Training Loss: 0.191\n",
+ "Test Loss: 0.431\n",
+ "Test Accuracy: 0.881\n",
+ "\n",
+ "Epoch: 28 out of 30\n",
+ "Training Loss: 0.195\n",
+ "Test Loss: 0.418\n",
+ "Test Accuracy: 0.882\n",
+ "\n",
+ "Epoch: 29 out of 30\n",
+ "Training Loss: 0.192\n",
+ "Test Loss: 0.390\n",
+ "Test Accuracy: 0.887\n",
+ "\n",
+ "Epoch: 30 out of 30\n",
+ "Training Loss: 0.185\n",
+ "Test Loss: 0.428\n",
+ "Test Accuracy: 0.875\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "from torchvision import datasets, transforms\n",
+ "from torch import nn, optim\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, 0.5),\n",
+ " (0.5, 0.5, 0.5))])\n",
+ "\n",
+ "# Download and load the training data\n",
+ "trainset = datasets.FashionMNIST(\n",
+ " '.pytorch/F_MNIST_data/', download=True, train=True, transform=transform)\n",
+ "\n",
+ "trainloader = torch.utils.data.DataLoader(\n",
+ " trainset, batch_size=64, shuffle=True)\n",
+ "\n",
+ "# Download and load the test data\n",
+ "testset = datasets.FashionMNIST(\n",
+ " '.pytorch/F_MNIST_data/', download=True, train=False,\n",
+ " transform=transform)\n",
+ "\n",
+ "testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)\n",
+ "\n",
+ "\n",
+ "class Classifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.fc1 = nn.Linear(784, 256)\n",
+ " self.fc2 = nn.Linear(256, 128)\n",
+ " self.fc3 = nn.Linear(128, 64)\n",
+ " self.fc4 = nn.Linear(64, 10)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " # make sure input tensor is flattened\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\n",
+ "\n",
+ "\n",
+ "model = Classifier()\n",
+ "\n",
+ "images, labels = next(iter(testloader))\n",
+ "\n",
+ "# Get the class probabilities\n",
+ "ps = torch.exp(model(images))\n",
+ "\n",
+ "# Make sure the shape is appropriate, we should get 10 class probabilities for\n",
+ "# 64 examples\n",
+ "print(ps.shape)\n",
+ "\n",
+ "top_p, top_class = ps.topk(1, dim=1)\n",
+ "# Look at the most likely classes for the first 10 examples\n",
+ "print(top_class[:10, :])\n",
+ "\n",
+ "\n",
+ "equals = top_class == labels.view(*top_class.shape)\n",
+ "\n",
+ "\n",
+ "accuracy = torch.mean(equals.type(torch.FloatTensor))\n",
+ "print(f'Accuracy: {accuracy.item()*100}%')\n",
+ "\n",
+ "\n",
+ "# Model begins\n",
+ "\n",
+ "model = Classifier()\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.Adam(model.parameters(), lr=0.003)\n",
+ "\n",
+ "epochs = 30\n",
+ "steps = 0\n",
+ "\n",
+ "trainLosses, testLosses = [], []\n",
+ "for e in range(epochs):\n",
+ " runningLoss = 0\n",
+ " for images, labels in trainloader:\n",
+ "\n",
+ " optimizer.zero_grad()\n",
+ "\n",
+ " log_ps = model(images)\n",
+ " loss = criterion(log_ps, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " runningLoss += loss.item()\n",
+ "\n",
+ " else:\n",
+ " testLoss = 0\n",
+ " accuracy = 0\n",
+ "\n",
+ " # Turn off gradients for validation step\n",
+ " with torch.no_grad():\n",
+ " for images, labels in testloader:\n",
+ " # Get the output\n",
+ " log_ps = model(images)\n",
+ " # Get the loss\n",
+ " testLoss += criterion(log_ps, labels)\n",
+ "\n",
+ " # Get the probabilities\n",
+ " ps = torch.exp(log_ps)\n",
+ " # Get the most likely class for each prediction\n",
+ " top_p, top_class = ps.topk(1, dim=1)\n",
+ " # Check if the predictions match the actual label\n",
+ " equals = top_class == labels.view(*top_class.shape)\n",
+ " # Update accuracy\n",
+ " accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
+ "\n",
+ " # Update train loss\n",
+ " trainLosses.append(runningLoss / len(trainloader))\n",
+ " # Update test loss\n",
+ " testLosses.append(testLoss / len(testloader))\n",
+ "\n",
+ " # Print output\n",
+ " print(f'Epoch: {e+1} out of {epochs}')\n",
+ " print(f'Training Loss: {runningLoss/len(trainloader):.3f}')\n",
+ " print(f'Test Loss: {testLoss/len(testloader):.3f}')\n",
+ " print(f'Test Accuracy: {accuracy/len(testloader):.3f}')\n",
+ " print()\n"
+ ]
+ },
+ {
+ "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
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/fc_model.py b/python/Deep Learning/Deep Learning with PyTorch/fc_model.py
new file mode 100644
index 0000000..9c259f7
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/fc_model.py
@@ -0,0 +1,104 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+
+class Network(nn.Module):
+ def __init__(self, input_size, output_size, hidden_layers, drop_p=0.5):
+ ''' Builds a feedforward network with arbitrary hidden layers.
+
+ Arguments
+ ---------
+ input_size: integer, size of the input layer
+ output_size: integer, size of the output layer
+ hidden_layers: list of integers, the sizes of the hidden layers
+
+ '''
+ super().__init__()
+ # Input to a hidden layer
+ self.hidden_layers = nn.ModuleList(
+ [nn.Linear(input_size, hidden_layers[0])])
+
+ # Add a variable number of more hidden layers
+ layer_sizes = zip(hidden_layers[:-1], hidden_layers[1:])
+ self.hidden_layers.extend([nn.Linear(h1, h2)
+ for h1, h2 in layer_sizes])
+
+ self.output = nn.Linear(hidden_layers[-1], output_size)
+
+ self.dropout = nn.Dropout(p=drop_p)
+
+ def forward(self, x):
+ ''' Forward pass through the network, returns the output logits '''
+
+ for each in self.hidden_layers:
+ x = F.relu(each(x))
+ x = self.dropout(x)
+ x = self.output(x)
+
+ return F.log_softmax(x, dim=1)
+
+
+def validation(model, testloader, criterion):
+ accuracy = 0
+ test_loss = 0
+ for images, labels in testloader:
+
+ images = images.resize_(images.size()[0], 784)
+
+ output = model.forward(images)
+ test_loss += criterion(output, labels).item()
+
+ # Calculating the accuracy
+ # Model's output is log-softmax, take exponential to get the probabilities
+ ps = torch.exp(output)
+ # Class with highest probability is our predicted class, compare with true label
+ equality = (labels.data == ps.max(1)[1])
+ # Accuracy is number of correct predictions divided by all predictions, just take the mean
+ accuracy += equality.type_as(torch.FloatTensor()).mean()
+
+ return test_loss, accuracy
+
+
+def train(model, trainloader, testloader, criterion, optimizer, epochs=5, print_every=40):
+
+ steps = 0
+ running_loss = 0
+ for e in range(epochs):
+ # Model in training mode, dropout is on
+ model.train()
+ for images, labels in trainloader:
+ steps += 1
+
+ # Flatten images into a 784 long vector
+ images.resize_(images.size()[0], 784)
+
+ optimizer.zero_grad()
+
+ output = model.forward(images)
+ loss = criterion(output, labels)
+ loss.backward()
+ optimizer.step()
+
+ running_loss += loss.item()
+
+ if steps % print_every == 0:
+ # Model in inference mode, dropout is off
+ model.eval()
+
+ # Turn off gradients for validation, will speed up inference
+ with torch.no_grad():
+ test_loss, accuracy = validation(
+ model, testloader, criterion)
+
+ print("Epoch: {}/{}.. ".format(e + 1, epochs),
+ "Training Loss: {:.3f}.. ".format(
+ running_loss / print_every),
+ "Test Loss: {:.3f}.. ".format(
+ test_loss / len(testloader)),
+ "Test Accuracy: {:.3f}".format(accuracy / len(testloader)))
+
+ running_loss = 0
+
+ # Make sure dropout and grads are on for training
+ model.train()
diff --git a/python/Deep Learning/Deep Learning with PyTorch/helper.py b/python/Deep Learning/Deep Learning with PyTorch/helper.py
new file mode 100644
index 0000000..5152f1f
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/helper.py
@@ -0,0 +1,95 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from torch import nn, optim
+from torch.autograd import Variable
+
+
+def test_network(net, trainloader):
+
+ criterion = nn.MSELoss()
+ optimizer = optim.Adam(net.parameters(), lr=0.001)
+
+ dataiter = iter(trainloader)
+ images, labels = dataiter.next()
+
+ # Create Variables for the inputs and targets
+ inputs = Variable(images)
+ targets = Variable(images)
+
+ # Clear the gradients from all Variables
+ optimizer.zero_grad()
+
+ # Forward pass, then backward pass, then update weights
+ output = net.forward(inputs)
+ loss = criterion(output, targets)
+ loss.backward()
+ optimizer.step()
+
+ return True
+
+
+def imshow(image, ax=None, title=None, normalize=True):
+ """Imshow for Tensor."""
+ if ax is None:
+ fig, ax = plt.subplots()
+ image = image.numpy().transpose((1, 2, 0))
+
+ if normalize:
+ mean = np.array([0.485, 0.456, 0.406])
+ std = np.array([0.229, 0.224, 0.225])
+ image = std * image + mean
+ image = np.clip(image, 0, 1)
+
+ ax.imshow(image)
+ ax.spines['top'].set_visible(False)
+ ax.spines['right'].set_visible(False)
+ ax.spines['left'].set_visible(False)
+ ax.spines['bottom'].set_visible(False)
+ ax.tick_params(axis='both', length=0)
+ ax.set_xticklabels('')
+ ax.set_yticklabels('')
+
+ return ax
+
+
+def view_recon(img, recon):
+ ''' Function for displaying an image (as a PyTorch Tensor) and its
+ reconstruction also a PyTorch Tensor
+ '''
+
+ fig, axes = plt.subplots(ncols=2, sharex=True, sharey=True)
+ axes[0].imshow(img.numpy().squeeze())
+ axes[1].imshow(recon.data.numpy().squeeze())
+ for ax in axes:
+ ax.axis('off')
+ ax.set_adjustable('box-forced')
+
+
+def view_classify(img, ps, version="MNIST"):
+ ''' Function for viewing an image and it's predicted classes.
+ '''
+ ps = ps.data.numpy().squeeze()
+
+ fig, (ax1, ax2) = plt.subplots(figsize=(6, 9), ncols=2)
+ ax1.imshow(img.resize_(1, 28, 28).numpy().squeeze())
+ ax1.axis('off')
+ ax2.barh(np.arange(10), ps)
+ ax2.set_aspect(0.1)
+ ax2.set_yticks(np.arange(10))
+ if version == "MNIST":
+ ax2.set_yticklabels(np.arange(10))
+ elif version == "Fashion":
+ ax2.set_yticklabels(['T-shirt/top',
+ 'Trouser',
+ 'Pullover',
+ 'Dress',
+ 'Coat',
+ 'Sandal',
+ 'Shirt',
+ 'Sneaker',
+ 'Bag',
+ 'Ankle Boot'], size='small')
+ ax2.set_title('Class Probability')
+ ax2.set_xlim(0, 1.1)
+
+ plt.tight_layout()
diff --git a/python/Deep Learning/Deep Learning with PyTorch/python_scripts/fc_model.py b/python/Deep Learning/Deep Learning with PyTorch/python_scripts/fc_model.py
new file mode 100644
index 0000000..9c259f7
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/python_scripts/fc_model.py
@@ -0,0 +1,104 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+
+class Network(nn.Module):
+ def __init__(self, input_size, output_size, hidden_layers, drop_p=0.5):
+ ''' Builds a feedforward network with arbitrary hidden layers.
+
+ Arguments
+ ---------
+ input_size: integer, size of the input layer
+ output_size: integer, size of the output layer
+ hidden_layers: list of integers, the sizes of the hidden layers
+
+ '''
+ super().__init__()
+ # Input to a hidden layer
+ self.hidden_layers = nn.ModuleList(
+ [nn.Linear(input_size, hidden_layers[0])])
+
+ # Add a variable number of more hidden layers
+ layer_sizes = zip(hidden_layers[:-1], hidden_layers[1:])
+ self.hidden_layers.extend([nn.Linear(h1, h2)
+ for h1, h2 in layer_sizes])
+
+ self.output = nn.Linear(hidden_layers[-1], output_size)
+
+ self.dropout = nn.Dropout(p=drop_p)
+
+ def forward(self, x):
+ ''' Forward pass through the network, returns the output logits '''
+
+ for each in self.hidden_layers:
+ x = F.relu(each(x))
+ x = self.dropout(x)
+ x = self.output(x)
+
+ return F.log_softmax(x, dim=1)
+
+
+def validation(model, testloader, criterion):
+ accuracy = 0
+ test_loss = 0
+ for images, labels in testloader:
+
+ images = images.resize_(images.size()[0], 784)
+
+ output = model.forward(images)
+ test_loss += criterion(output, labels).item()
+
+ # Calculating the accuracy
+ # Model's output is log-softmax, take exponential to get the probabilities
+ ps = torch.exp(output)
+ # Class with highest probability is our predicted class, compare with true label
+ equality = (labels.data == ps.max(1)[1])
+ # Accuracy is number of correct predictions divided by all predictions, just take the mean
+ accuracy += equality.type_as(torch.FloatTensor()).mean()
+
+ return test_loss, accuracy
+
+
+def train(model, trainloader, testloader, criterion, optimizer, epochs=5, print_every=40):
+
+ steps = 0
+ running_loss = 0
+ for e in range(epochs):
+ # Model in training mode, dropout is on
+ model.train()
+ for images, labels in trainloader:
+ steps += 1
+
+ # Flatten images into a 784 long vector
+ images.resize_(images.size()[0], 784)
+
+ optimizer.zero_grad()
+
+ output = model.forward(images)
+ loss = criterion(output, labels)
+ loss.backward()
+ optimizer.step()
+
+ running_loss += loss.item()
+
+ if steps % print_every == 0:
+ # Model in inference mode, dropout is off
+ model.eval()
+
+ # Turn off gradients for validation, will speed up inference
+ with torch.no_grad():
+ test_loss, accuracy = validation(
+ model, testloader, criterion)
+
+ print("Epoch: {}/{}.. ".format(e + 1, epochs),
+ "Training Loss: {:.3f}.. ".format(
+ running_loss / print_every),
+ "Test Loss: {:.3f}.. ".format(
+ test_loss / len(testloader)),
+ "Test Accuracy: {:.3f}".format(accuracy / len(testloader)))
+
+ running_loss = 0
+
+ # Make sure dropout and grads are on for training
+ model.train()
diff --git a/python/Deep Learning/Deep Learning with PyTorch/python_scripts/part5_inference_and_validation.py b/python/Deep Learning/Deep Learning with PyTorch/python_scripts/part5_inference_and_validation.py
new file mode 100644
index 0000000..0a66a06
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/python_scripts/part5_inference_and_validation.py
@@ -0,0 +1,130 @@
+import torch
+from torchvision import datasets, transforms
+from torch import nn, optim
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+
+# Define a transform to normalize the data
+transform = transforms.Compose([transforms.ToTensor(),
+ transforms.Normalize((0.5, 0.5, 0.5),
+ (0.5, 0.5, 0.5))])
+
+# Download and load the training data
+trainset = datasets.FashionMNIST(
+ '.pytorch/F_MNIST_data/', download=True, train=True, transform=transform)
+
+trainloader = torch.utils.data.DataLoader(
+ trainset, batch_size=64, shuffle=True)
+
+# Download and load the test data
+testset = datasets.FashionMNIST(
+ '.pytorch/F_MNIST_data/', download=True, train=False,
+ transform=transform)
+
+testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)
+
+
+class Classifier(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.fc1 = nn.Linear(784, 256)
+ self.fc2 = nn.Linear(256, 128)
+ self.fc3 = nn.Linear(128, 64)
+ self.fc4 = nn.Linear(64, 10)
+
+ def forward(self, x):
+ # make sure input tensor is flattened
+ x = x.view(x.shape[0], -1)
+
+ x = F.relu(self.fc1(x))
+ x = F.relu(self.fc2(x))
+ x = F.relu(self.fc3(x))
+ x = F.log_softmax(self.fc4(x), dim=1)
+
+ return x
+
+
+model = Classifier()
+
+images, labels = next(iter(testloader))
+
+# Get the class probabilities
+ps = torch.exp(model(images))
+
+# Make sure the shape is appropriate, we should get 10 class probabilities for
+# 64 examples
+print(ps.shape)
+
+top_p, top_class = ps.topk(1, dim=1)
+# Look at the most likely classes for the first 10 examples
+print(top_class[:10, :])
+
+
+equals = top_class == labels.view(*top_class.shape)
+
+
+accuracy = torch.mean(equals.type(torch.FloatTensor))
+print(f'Accuracy: {accuracy.item()*100}%')
+
+
+# Model begins
+
+model = Classifier()
+criterion = nn.NLLLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.003)
+
+epochs = 30
+steps = 0
+
+trainLosses, testLosses = [], []
+for e in range(epochs):
+ runningLoss = 0
+ for images, labels in trainloader:
+
+ optimizer.zero_grad()
+
+ log_ps = model(images)
+ loss = criterion(log_ps, labels)
+ loss.backward()
+ optimizer.step()
+
+ runningLoss += loss.item()
+
+ else:
+ testLoss = 0
+ accuracy = 0
+
+ # Turn off gradients for validation step
+ with torch.no_grad():
+ for images, labels in testloader:
+ # Get the output
+ log_ps = model(images)
+ # Get the loss
+ testLoss += criterion(log_ps, labels)
+
+ # Get the probabilities
+ ps = torch.exp(log_ps)
+ # Get the most likely class for each prediction
+ top_p, top_class = ps.topk(1, dim=1)
+ # Check if the predictions match the actual label
+ equals = top_class == labels.view(*top_class.shape)
+ # Update accuracy
+ accuracy += torch.mean(equals.type(torch.FloatTensor))
+
+ # Update train loss
+ trainLosses.append(runningLoss / len(trainloader))
+ # Update test loss
+ testLosses.append(testLoss / len(testloader))
+
+ # Print output
+ print(f'Epoch: {e+1} out of {epochs}')
+ print(f'Training Loss: {runningLoss/len(trainloader):.3f}')
+ print(f'Test Loss: {testLoss/len(testloader):.3f}')
+ print(f'Test Accuracy: {accuracy/len(testloader):.3f}')
+ print()
+
+
+plt.plot(trainLosses, label='Training loss')
+plt.plot(testLosses, label='Validation loss')
+plt.legend(frameon=False)
+plt.show()
![](\"assets/simple_neuron.png\")
\n",
+ "\n",
+ "Mathematically this looks like: \n",
+ "\n",
+ "$$\n",
+ "\\begin{align}\n",
+ "y &= f(w_1 x_1 + w_2 x_2 + b) \\\\\n",
+ "y &= f\\left(\\sum_i w_i x_i +b \\right)\n",
+ "\\end{align}\n",
+ "$$\n",
+ "\n",
+ "With vectors this is the dot/inner product of two vectors:\n",
+ "\n",
+ "$$\n",
+ "h = \\begin{bmatrix}\n",
+ "x_1 \\, x_2 \\cdots x_n\n",
+ "\\end{bmatrix}\n",
+ "\\cdot \n",
+ "\\begin{bmatrix}\n",
+ " w_1 \\\\\n",
+ " w_2 \\\\\n",
+ " \\vdots \\\\\n",
+ " w_n\n",
+ "\\end{bmatrix}\n",
+ "$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Tensors\n",
+ "\n",
+ "It turns out neural network computations are just a bunch of linear algebra operations on *tensors*, a generalization of matrices. A vector is a 1-dimensional tensor, a matrix is a 2-dimensional tensor, an array with three indices is a 3-dimensional tensor (RGB color images for example). The fundamental data structure for neural networks are tensors and PyTorch (as well as pretty much every other deep learning framework) is built around tensors.\n",
+ "\n",
+ "![](\"assets/tensor_examples.svg\")
\n",
+ "\n",
+ "With the basics covered, it's time to explore how we can use PyTorch to build a simple neural network."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# First, import PyTorch\n",
+ "import torch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def activation(x):\n",
+ " \"\"\" Sigmoid activation function \n",
+ " \n",
+ " Arguments\n",
+ " ---------\n",
+ " x: torch.Tensor\n",
+ " \"\"\"\n",
+ " return 1/(1+torch.exp(-x))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "### Generate some data\n",
+ "torch.manual_seed(7) # Set the random seed so things are predictable\n",
+ "\n",
+ "# Features are 3 random normal variables\n",
+ "features = torch.randn((1, 5))\n",
+ "# True weights for our data, random normal variables again\n",
+ "weights = torch.randn_like(features)\n",
+ "# and a true bias term\n",
+ "bias = torch.randn((1, 1))"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[-0.9179, -0.4578, -0.7245, 1.2799, -0.9941]])"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "torch.randn_like(torch.randn((1, 5)))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Above I generated data we can use to get the output of our simple network. This is all just random for now, going forward we'll start using normal data. Going through each relevant line:\n",
+ "\n",
+ "`features = torch.randn((1, 5))` creates a tensor with shape `(1, 5)`, one row and five columns, that contains values randomly distributed according to the normal distribution with a mean of zero and standard deviation of one. \n",
+ "\n",
+ "`weights = torch.randn_like(features)` creates another tensor with the same shape as `features`, again containing values from a normal distribution.\n",
+ "\n",
+ "Finally, `bias = torch.randn((1, 1))` creates a single value from a normal distribution.\n",
+ "\n",
+ "PyTorch tensors can be added, multiplied, subtracted, etc, just like Numpy arrays. In general, you'll use PyTorch tensors pretty much the same way you'd use Numpy arrays. They come with some nice benefits though such as GPU acceleration which we'll get to later. For now, use the generated data to calculate the output of this simple single layer network. \n",
+ "> **Exercise**: Calculate the output of the network with input features `features`, weights `weights`, and bias `bias`. Similar to Numpy, PyTorch has a [`torch.sum()`](https://pytorch.org/docs/stable/torch.html#torch.sum) function, as well as a `.sum()` method on tensors, for taking sums. Use the function `activation` defined above as the activation function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[-1.6619]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "## Calculate the output of this network using the weights and bias tensors\n",
+ "sum = torch.matmul(features, weights.view(5, 1)) + bias\n",
+ "print(sum)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can do the multiplication and sum in the same operation using a matrix multiplication. In general, you'll want to use matrix multiplications since they are more efficient and accelerated using modern libraries and high-performance computing on GPUs.\n",
+ "\n",
+ "Here, we want to do a matrix multiplication of the features and the weights. For this we can use [`torch.mm()`](https://pytorch.org/docs/stable/torch.html#torch.mm) or [`torch.matmul()`](https://pytorch.org/docs/stable/torch.html#torch.matmul) which is somewhat more complicated and supports broadcasting. If we try to do it with `features` and `weights` as they are, we'll get an error\n",
+ "\n",
+ "```python\n",
+ ">> torch.mm(features, weights)\n",
+ "\n",
+ "---------------------------------------------------------------------------\n",
+ "RuntimeError Traceback (most recent call last)\n",
+ "
\n",
+ "\n",
+ "The first layer shown on the bottom here are the inputs, understandably called the **input layer**. The middle layer is called the **hidden layer**, and the final layer (on the right) is the **output layer**. We can express this network mathematically with matrices again and use matrix multiplication to get linear combinations for each unit in one operation. For example, the hidden layer ($h_1$ and $h_2$ here) can be calculated \n",
+ "\n",
+ "$$\n",
+ "\\vec{h} = [h_1 \\, h_2] = \n",
+ "\\begin{bmatrix}\n",
+ "x_1 \\, x_2 \\cdots \\, x_n\n",
+ "\\end{bmatrix}\n",
+ "\\cdot \n",
+ "\\begin{bmatrix}\n",
+ " w_{11} & w_{12} \\\\\n",
+ " w_{21} &w_{22} \\\\\n",
+ " \\vdots &\\vdots \\\\\n",
+ " w_{n1} &w_{n2}\n",
+ "\\end{bmatrix}\n",
+ "$$\n",
+ "\n",
+ "The output for this small network is found by treating the hidden layer as inputs for the output unit. The network output is expressed simply\n",
+ "\n",
+ "$$\n",
+ "y = f_2 \\! \\left(\\, f_1 \\! \\left(\\vec{x} \\, \\mathbf{W_1}\\right) \\mathbf{W_2} \\right)\n",
+ "$$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "### Generate some data\n",
+ "torch.manual_seed(7) # Set the random seed so things are predictable\n",
+ "\n",
+ "# Features are 3 random normal variables\n",
+ "features = torch.randn((1, 3))\n",
+ "\n",
+ "# Define the size of each layer in our network\n",
+ "n_input = features.shape[1] # Number of input units, must match number of input features\n",
+ "n_hidden = 2 # Number of hidden units \n",
+ "n_output = 1 # Number of output units\n",
+ "\n",
+ "# Weights for inputs to hidden layer\n",
+ "W1 = torch.randn(n_input, n_hidden)\n",
+ "# Weights for hidden layer to output layer\n",
+ "W2 = torch.randn(n_hidden, n_output)\n",
+ "\n",
+ "# and bias terms for hidden and output layers\n",
+ "B1 = torch.randn((1, n_hidden))\n",
+ "B2 = torch.randn((1, n_output))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "> **Exercise:** Calculate the output for this multi-layer network using the weights `W1` & `W2`, and the biases, `B1` & `B2`. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 0.3171]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "## Your solution here\n",
+ "h = torch.mm(features, W1) + B1\n",
+ "h = activation(h)\n",
+ "output = torch.mm(h, W2) + B2\n",
+ "output = activation(output)\n",
+ "print(output)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "If you did this correctly, you should see the output `tensor([[ 0.3171]])`.\n",
+ "\n",
+ "The number of hidden units a parameter of the network, often called a **hyperparameter** to differentiate it from the weights and biases parameters. As you'll see later when we discuss training a neural network, the more hidden units a network has, and the more layers, the better able it is to learn from data and make accurate predictions."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Numpy to Torch and back\n",
+ "\n",
+ "Special bonus section! PyTorch has a great feature for converting between Numpy arrays and Torch tensors. To create a tensor from a Numpy array, use `torch.from_numpy()`. To convert a tensor to a Numpy array, use the `.numpy()` method."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 0.25916044, 0.07974115, 0.13661261],\n",
+ " [ 0.12537927, 0.68318453, 0.24728824],\n",
+ " [ 0.49867652, 0.62760544, 0.84363415],\n",
+ " [ 0.39216351, 0.87075396, 0.0653991 ]])"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "a = np.random.rand(4,3)\n",
+ "a"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[ 0.2592, 0.0797, 0.1366],\n",
+ " [ 0.1254, 0.6832, 0.2473],\n",
+ " [ 0.4987, 0.6276, 0.8436],\n",
+ " [ 0.3922, 0.8708, 0.0654]], dtype=torch.float64)"
+ ]
+ },
+ "execution_count": 28,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b = torch.from_numpy(a)\n",
+ "b"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 0.25916044, 0.07974115, 0.13661261],\n",
+ " [ 0.12537927, 0.68318453, 0.24728824],\n",
+ " [ 0.49867652, 0.62760544, 0.84363415],\n",
+ " [ 0.39216351, 0.87075396, 0.0653991 ]])"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "b.numpy()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The memory is shared between the Numpy array and Torch tensor, so if you change the values in-place of one object, the other will change as well."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 30,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[ 0.5183, 0.1595, 0.2732],\n",
+ " [ 0.2508, 1.3664, 0.4946],\n",
+ " [ 0.9974, 1.2552, 1.6873],\n",
+ " [ 0.7843, 1.7415, 0.1308]], dtype=torch.float64)"
+ ]
+ },
+ "execution_count": 30,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Multiply PyTorch Tensor by 2, in place\n",
+ "b.mul_(2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 0.51832089, 0.15948231, 0.27322523],\n",
+ " [ 0.25075854, 1.36636907, 0.49457648],\n",
+ " [ 0.99735305, 1.25521088, 1.68726831],\n",
+ " [ 0.78432703, 1.74150792, 0.1307982 ]])"
+ ]
+ },
+ "execution_count": 31,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Numpy array matches new values from Tensor\n",
+ "a"
+ ]
+ },
+ {
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb
new file mode 100644
index 0000000..7754816
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 2 - Neural Networks in PyTorch (Exercises).ipynb
@@ -0,0 +1,870 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Neural networks with PyTorch\n",
+ "\n",
+ "Deep learning networks tend to be massive with dozens or hundreds of layers, that's where the term \"deep\" comes from. You can build one of these deep networks using only weight matrices as we did in the previous notebook, but in general it's very cumbersome and difficult to implement. PyTorch has a nice module `nn` that provides a nice way to efficiently build large neural networks."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Import necessary packages\n",
+ "\n",
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import numpy as np\n",
+ "import torch\n",
+ "\n",
+ "import helper\n",
+ "\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "Now we're going to build a larger network that can solve a (formerly) difficult problem, identifying text in an image. Here we'll use the MNIST dataset which consists of greyscale handwritten digits. Each image is 28x28 pixels, you can see a sample below\n",
+ "\n",
+ "
\n",
+ "\n",
+ "Our goal is to build a neural network that can take one of these images and predict the digit in the image.\n",
+ "\n",
+ "First up, we need to get our dataset. This is provided through the `torchvision` package. The code below will download the MNIST dataset, then create training and test datasets for us. Don't worry too much about the details here, you'll learn more about this later."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
+ "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
+ "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
+ "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
+ "Processing...\n",
+ "Done!\n"
+ ]
+ }
+ ],
+ "source": [
+ "### Run this cell\n",
+ "\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Define a transform to normalize the data\n",
+ "transform = transforms.Compose([transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5,), (0.5,)),\n",
+ " ])\n",
+ "\n",
+ "# Download and load the training data\n",
+ "trainset = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=True, transform=transform)\n",
+ "trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We have the training data loaded into `trainloader` and we make that an iterator with `iter(trainloader)`. Later, we'll use this to loop through the dataset for training, like\n",
+ "\n",
+ "```python\n",
+ "for image, label in trainloader:\n",
+ " ## do things with images and labels\n",
+ "```\n",
+ "\n",
+ "You'll notice I created the `trainloader` with a batch size of 64, and `shuffle=True`. The batch size is the number of images we get in one iteration from the data loader and pass through our network, often called a *batch*. And `shuffle=True` tells it to shuffle the dataset every time we start going through the data loader again. But here I'm just grabbing the first batch so we can check out the data. We can see below that `images` is just a tensor with size `(64, 1, 28, 28)`. So, 64 images per batch, 1 color channel, and 28x28 images."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "
\n",
+ "\n",
+ "Here we see that the probability for each class is roughly the same. This is representing an untrained network, it hasn't seen any data yet so it just returns a uniform distribution with equal probabilities for each class.\n",
+ "\n",
+ "To calculate this probability distribution, we often use the [**softmax** function](https://en.wikipedia.org/wiki/Softmax_function). Mathematically this looks like\n",
+ "\n",
+ "$$\n",
+ "\\Large \\sigma(x_i) = \\cfrac{e^{x_i}}{\\sum_k^K{e^{x_k}}}\n",
+ "$$\n",
+ "\n",
+ "What this does is squish each input $x_i$ between 0 and 1 and normalizes the values to give you a proper probability distribution where the probabilites sum up to one.\n",
+ "\n",
+ "> **Exercise:** Implement a function `softmax` that performs the softmax calculation and returns probability distributions for each example in the batch. Note that you'll need to pay attention to the shapes when doing this. If you have a tensor `a` with shape `(64, 10)` and a tensor `b` with shape `(64,)`, doing `a/b` will give you an error because PyTorch will try to do the division across the columns (called broadcasting) but you'll get a size mismatch. The way to think about this is for each of the 64 examples, you only want to divide by one value, the sum in the denominator. So you need `b` to have a shape of `(64, 1)`. This way PyTorch will divide the 10 values in each row of `a` by the one value in each row of `b`. Pay attention to how you take the sum as well. You'll need to define the `dim` keyword in `torch.sum`. Setting `dim=0` takes the sum across the rows while `dim=1` takes the sum across the columns."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "torch.Size([64, 10])\n",
+ "tensor([ 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000, 1.0000,\n",
+ " 1.0000])\n"
+ ]
+ }
+ ],
+ "source": [
+ "def softmax(x):\n",
+ " ## TODO: Implement the softmax function here\n",
+ " return torch.exp(x) / torch.sum(torch.exp(x), dim=1).view(-1, 1)\n",
+ "\n",
+ "# Here, out should be the output of the network in the previous excercise with shape (64,10)\n",
+ "probabilities = softmax(out)\n",
+ "\n",
+ "# Does it have the right shape? Should be (64, 10)\n",
+ "print(probabilities.shape)\n",
+ "# Does it sum to 1?\n",
+ "print(probabilities.sum(dim=1))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Building networks with PyTorch\n",
+ "\n",
+ "PyTorch provides a module `nn` that makes building networks much simpler. Here I'll show you how to build the same one as above with 784 inputs, 256 hidden units, 10 output units and a softmax output."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from torch import nn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Network(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " \n",
+ " # Inputs to hidden layer linear transformation\n",
+ " self.hidden = nn.Linear(784, 256)\n",
+ " # Output layer, 10 units - one for each digit\n",
+ " self.output = nn.Linear(256, 10)\n",
+ " \n",
+ " # Define sigmoid activation and softmax output \n",
+ " self.sigmoid = nn.Sigmoid()\n",
+ " self.softmax = nn.Softmax(dim=1)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # Pass the input tensor through each of our operations\n",
+ " x = self.hidden(x)\n",
+ " x = self.sigmoid(x)\n",
+ " x = self.output(x)\n",
+ " x = self.softmax(x)\n",
+ " \n",
+ " return x"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Let's go through this bit by bit.\n",
+ "\n",
+ "```python\n",
+ "class Network(nn.Module):\n",
+ "```\n",
+ "\n",
+ "Here we're inheriting from `nn.Module`. Combined with `super().__init__()` this creates a class that tracks the architecture and provides a lot of useful methods and attributes. It is mandatory to inherit from `nn.Module` when you're creating a class for your network. The name of the class itself can be anything.\n",
+ "\n",
+ "```python\n",
+ "self.hidden = nn.Linear(784, 256)\n",
+ "```\n",
+ "\n",
+ "This line creates a module for a linear transformation, $x\\mathbf{W} + b$, with 784 inputs and 256 outputs and assigns it to `self.hidden`. The module automatically creates the weight and bias tensors which we'll use in the `forward` method. You can access the weight and bias tensors once the network (`net`) is created with `net.hidden.weight` and `net.hidden.bias`.\n",
+ "\n",
+ "```python\n",
+ "self.output = nn.Linear(256, 10)\n",
+ "```\n",
+ "\n",
+ "Similarly, this creates another linear transformation with 256 inputs and 10 outputs.\n",
+ "\n",
+ "```python\n",
+ "self.sigmoid = nn.Sigmoid()\n",
+ "self.softmax = nn.Softmax(dim=1)\n",
+ "```\n",
+ "\n",
+ "Here I defined operations for the sigmoid activation and softmax output. Setting `dim=1` in `nn.Softmax(dim=1)` calculates softmax across the columns.\n",
+ "\n",
+ "```python\n",
+ "def forward(self, x):\n",
+ "```\n",
+ "\n",
+ "PyTorch networks created with `nn.Module` must have a `forward` method defined. It takes in a tensor `x` and passes it through the operations you defined in the `__init__` method.\n",
+ "\n",
+ "```python\n",
+ "x = self.hidden(x)\n",
+ "x = self.sigmoid(x)\n",
+ "x = self.output(x)\n",
+ "x = self.softmax(x)\n",
+ "```\n",
+ "\n",
+ "Here the input tensor `x` is passed through each operation a reassigned to `x`. We can see that the input tensor goes through the hidden layer, then a sigmoid function, then the output layer, and finally the softmax function. It doesn't matter what you name the variables here, as long as the inputs and outputs of the operations match the network architecture you want to build. The order in which you define things in the `__init__` method doesn't matter, but you'll need to sequence the operations correctly in the `forward` method.\n",
+ "\n",
+ "Now we can create a `Network` object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Network(\n",
+ " (hidden): Linear(in_features=784, out_features=256, bias=True)\n",
+ " (output): Linear(in_features=256, out_features=10, bias=True)\n",
+ " (sigmoid): Sigmoid()\n",
+ " (softmax): Softmax()\n",
+ ")"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Create the network and look at it's text representation\n",
+ "model = Network()\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can define the network somewhat more concisely and clearly using the `torch.nn.functional` module. This is the most common way you'll see networks defined as many operations are simple element-wise functions. We normally import this module as `F`, `import torch.nn.functional as F`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 28,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch.nn.functional as F\n",
+ "\n",
+ "class Network(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " # Inputs to hidden layer linear transformation\n",
+ " self.hidden = nn.Linear(784, 256)\n",
+ " # Output layer, 10 units - one for each digit\n",
+ " self.output = nn.Linear(256, 10)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # Hidden layer with sigmoid activation\n",
+ " x = F.sigmoid(self.hidden(x))\n",
+ " # Output layer with softmax activation\n",
+ " x = F.softmax(self.output(x), dim=1)\n",
+ " \n",
+ " return x"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Activation functions\n",
+ "\n",
+ "So far we've only been looking at the softmax activation, but in general any function can be used as an activation function. The only requirement is that for a network to approximate a non-linear function, the activation functions must be non-linear. Here are a few more examples of common activation functions: Tanh (hyperbolic tangent), and ReLU (rectified linear unit).\n",
+ "\n",
+ "![](\"assets/activation.png\")
\n",
+ "\n",
+ "In practice, the ReLU function is used almost exclusively as the activation function for hidden layers."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Your Turn to Build a Network\n",
+ "\n",
+ "![](\"assets/mlp_mnist.png\")
\n",
+ "\n",
+ "> **Exercise:** Create a network with 784 input units, a hidden layer with 128 units and a ReLU activation, then a hidden layer with 64 units and a ReLU activation, and finally an output layer with a softmax activation as shown above. You can use a ReLU activation with the `nn.ReLU` module or `F.relu` function."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "Network(\n",
+ " (l1): Linear(in_features=784, out_features=128, bias=True)\n",
+ " (l2): Linear(in_features=128, out_features=64, bias=True)\n",
+ " (l3): Linear(in_features=64, out_features=10, bias=True)\n",
+ ")"
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "## Your solution here\n",
+ "\n",
+ "class Network(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " # Define the layers 128, 64, 10 units each\n",
+ " self.l1 = nn.Linear(784, 128)\n",
+ " self.l2 = nn.Linear(128, 64)\n",
+ " # Define output layer\n",
+ " self.l3 = nn.Linear(64, 10)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " \"\"\"Forward pass through the network - reuturns the output\"\"\"\n",
+ " x = self.l1(x)\n",
+ " x = F.relu(x)\n",
+ " \n",
+ " x = self.l2(x)\n",
+ " x = F.relu(x)\n",
+ " \n",
+ " x = self.l3(x)\n",
+ " x = F.softmax(x, dim=1)\n",
+ " \n",
+ " return x\n",
+ "\n",
+ "model=Network()\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Initializing weights and biases\n",
+ "\n",
+ "The weights and such are automatically initialized for you, but it's possible to customize how they are initialized. The weights and biases are tensors attached to the layer you defined, you can get them with `model.fc1.weight` for instance."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 22,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Parameter containing:\n",
+ "tensor([[-1.0776e-02, 2.0526e-02, -1.5042e-02, ..., -4.7536e-03,\n",
+ " 2.5714e-03, -5.5181e-03],\n",
+ " [-1.8762e-02, -2.5858e-02, -2.6485e-02, ..., -1.0233e-02,\n",
+ " -2.2680e-02, -5.5377e-04],\n",
+ " [-1.3932e-02, 6.4527e-03, -2.6832e-03, ..., 2.3186e-02,\n",
+ " 2.8184e-02, -5.7248e-04],\n",
+ " ...,\n",
+ " [ 1.4060e-02, 3.0088e-02, -2.8885e-03, ..., 2.5048e-02,\n",
+ " -1.9844e-02, 6.5543e-03],\n",
+ " [ 1.5551e-02, 8.4835e-03, 1.5654e-04, ..., -1.5493e-02,\n",
+ " -4.2152e-03, -2.5316e-02],\n",
+ " [ 1.2114e-03, -1.4411e-02, 1.9116e-02, ..., 3.1978e-02,\n",
+ " 1.9531e-02, -3.2406e-02]])\n",
+ "Parameter containing:\n",
+ "tensor(1.00000e-02 *\n",
+ " [-2.7470, 2.9781, 2.5320, -2.3808, 3.0487, -0.7365, -2.4079,\n",
+ " 0.4414, -1.7073, 1.8509, 3.3353, -0.6008, -3.2928, 3.3918,\n",
+ " 2.9831, 0.0983, -1.1983, -2.0790, 0.9813, -0.6745, -0.3347,\n",
+ " -0.8737, -2.7929, 1.2551, 0.2288, -2.4784, 0.0190, 1.2828,\n",
+ " -0.6021, 2.4832, 3.4782, -0.3269, -1.7032, -3.1000, -2.4096,\n",
+ " -1.1523, -3.1894, 3.4164, -3.0275, -2.3891, -0.0275, 1.7851,\n",
+ " 3.1205, 1.2810, 1.0525, -0.6538, -1.6390, -2.4172, 2.1895,\n",
+ " -1.8027, -0.4446, -1.5385, 2.0806, -1.9547, -0.4899, -1.0428,\n",
+ " 3.3237, 1.0272, 1.2687, 0.9785, -0.6819, -1.0355, -3.1642,\n",
+ " 0.9449, -0.3841, 2.8396, 0.5092, 2.9105, -1.7338, -2.2073,\n",
+ " 1.2315, 1.6605, 0.9994, -0.9812, -1.5683, -0.1603, -0.3632,\n",
+ " 0.3852, -1.0125, 0.2518, 0.2360, 3.5688, -0.3973, 0.8222,\n",
+ " -0.1480, 0.7442, 2.6121, -2.9418, 1.2141, 0.0198, -0.6789,\n",
+ " -0.8365, -0.4946, -0.7336, -0.1345, 1.7144, -1.2053, 1.8478,\n",
+ " -2.6136, 3.3724, -0.7037, -2.8251, -3.3915, 1.9541, 1.3929,\n",
+ " 0.4494, -1.4477, -3.0928, 1.5461, 2.9698, -1.2177, 3.4206,\n",
+ " -0.8522, -0.1440, 0.8285, 0.1339, 0.4546, 2.1396, 1.3242,\n",
+ " 0.1970, 1.6910, 1.9873, 2.1056, -1.9118, 0.0454, -0.4995,\n",
+ " 3.3401, 2.1109])\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(model.l1.weight)\n",
+ "print(model.l1.bias)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "For custom initialization, we want to modify these tensors in place. These are actually autograd *Variables*, so we need to get back the actual tensors with `model.fc1.weight.data`. Once we have the tensors, we can fill them with zeros (for biases) or random normal values."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
+ " 0., 0., 0., 0., 0., 0., 0., 0.])"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Set biases to all zeros\n",
+ "model.l1.bias.data.fill_(0)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "tensor([[-2.3535e-03, -4.0847e-03, 6.6107e-03, ..., 1.3488e-02,\n",
+ " -3.0676e-03, 4.7938e-03],\n",
+ " [ 2.1113e-02, -1.3056e-02, -1.5310e-02, ..., 1.2427e-03,\n",
+ " 2.0526e-02, -3.7705e-03],\n",
+ " [ 1.2847e-02, -3.6961e-03, 1.8160e-02, ..., -5.9606e-03,\n",
+ " -1.5045e-02, -9.3461e-03],\n",
+ " ...,\n",
+ " [-7.3355e-03, 3.1985e-03, 1.9387e-03, ..., -1.1342e-02,\n",
+ " 3.1593e-04, -2.1606e-03],\n",
+ " [-3.4460e-03, 1.0747e-03, 1.1796e-02, ..., 3.0916e-03,\n",
+ " -1.3553e-02, -6.0074e-03],\n",
+ " [-3.2343e-03, -9.9594e-03, 9.7654e-03, ..., 6.7241e-03,\n",
+ " -4.3026e-03, 5.2910e-03]])"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# sample from random normal with standard dev = 0.01\n",
+ "model.l1.weight.data.normal_(std=0.01)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Forward pass\n",
+ "\n",
+ "Now that we have a network, let's see what happens when we pass in an image."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "![](\"assets/function_approx.png\")
\n",
+ "\n",
+ "At first the network is naive, it doesn't know the function mapping the inputs to the outputs. We train the network by showing it examples of real data, then adjusting the network parameters such that it approximates this function.\n",
+ "\n",
+ "To find these parameters, we need to know how poorly the network is predicting the real outputs. For this we calculate a **loss function** (also called the cost), a measure of our prediction error. For example, the mean squared loss is often used in regression and binary classification problems\n",
+ "\n",
+ "$$\n",
+ "\\large \\ell = \\frac{1}{2n}\\sum_i^n{\\left(y_i - \\hat{y}_i\\right)^2}\n",
+ "$$\n",
+ "\n",
+ "where $n$ is the number of training examples, $y_i$ are the true labels, and $\\hat{y}_i$ are the predicted labels.\n",
+ "\n",
+ "By minimizing this loss with respect to the network parameters, we can find configurations where the loss is at a minimum and the network is able to predict the correct labels with high accuracy. We find this minimum using a process called **gradient descent**. The gradient is the slope of the loss function and points in the direction of fastest change. To get to the minimum in the least amount of time, we then want to follow the gradient (downwards). You can think of this like descending a mountain by following the steepest slope to the base.\n",
+ "\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Backpropagation\n",
+ "\n",
+ "For single layer networks, gradient descent is straightforward to implement. However, it's more complicated for deeper, multilayer neural networks like the one we've built. Complicated enough that it took about 30 years before researchers figured out how to train multilayer networks.\n",
+ "\n",
+ "Training multilayer networks is done through **backpropagation** which is really just an application of the chain rule from calculus. It's easiest to understand if we convert a two layer network into a graph representation.\n",
+ "\n",
+ "
\n",
+ "\n",
+ "In the forward pass through the network, our data and operations go from bottom to top here. We pass the input $x$ through a linear transformation $L_1$ with weights $W_1$ and biases $b_1$. The output then goes through the sigmoid operation $S$ and another linear transformation $L_2$. Finally we calculate the loss $\\ell$. We use the loss as a measure of how bad the network's predictions are. The goal then is to adjust the weights and biases to minimize the loss.\n",
+ "\n",
+ "To train the weights with gradient descent, we propagate the gradient of the loss backwards through the network. Each operation has some gradient between the inputs and outputs. As we send the gradients backwards, we multiply the incoming gradient with the gradient for the operation. Mathematically, this is really just calculating the gradient of the loss with respect to the weights using the chain rule.\n",
+ "\n",
+ "$$\n",
+ "\\large \\frac{\\partial \\ell}{\\partial W_1} = \\frac{\\partial L_1}{\\partial W_1} \\frac{\\partial S}{\\partial L_1} \\frac{\\partial L_2}{\\partial S} \\frac{\\partial \\ell}{\\partial L_2}\n",
+ "$$\n",
+ "\n",
+ "**Note:** I'm glossing over a few details here that require some knowledge of vector calculus, but they aren't necessary to understand what's going on.\n",
+ "\n",
+ "We update our weights using this gradient with some learning rate $\\alpha$. \n",
+ "\n",
+ "$$\n",
+ "\\large W^\\prime_1 = W_1 - \\alpha \\frac{\\partial \\ell}{\\partial W_1}\n",
+ "$$\n",
+ "\n",
+ "The learning rate $\\alpha$ is set such that the weight update steps are small enough that the iterative method settles in a minimum."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Losses in PyTorch\n",
+ "\n",
+ "Let's start by seeing how we calculate the loss with PyTorch. Through the `nn` module, PyTorch provides losses such as the cross-entropy loss (`nn.CrossEntropyLoss`). You'll usually see the loss assigned to `criterion`. As noted in the last part, with a classification problem such as MNIST, we're using the softmax function to predict class probabilities. With a softmax output, you want to use cross-entropy as the loss. To actually calculate the loss, you first define the criterion then pass in the output of your network and the correct labels.\n",
+ "\n",
+ "Something really important to note here. Looking at [the documentation for `nn.CrossEntropyLoss`](https://pytorch.org/docs/stable/nn.html#torch.nn.CrossEntropyLoss),\n",
+ "\n",
+ "> This criterion combines `nn.LogSoftmax()` and `nn.NLLLoss()` in one single class.\n",
+ ">\n",
+ "> The input is expected to contain scores for each class.\n",
+ "\n",
+ "This means we need to pass in the raw output of our network into the loss, not the output of the softmax function. This raw output is usually called the *logits* or *scores*. We use the logits because softmax gives you probabilities which will often be very close to zero or one but floating-point numbers can't accurately represent values near zero or one ([read more here](https://docs.python.org/3/tutorial/floatingpoint.html)). It's usually best to avoid doing calculations with probabilities, typically we use log-probabilities."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import torch\n",
+ "from torch import nn\n",
+ "import torch.nn.functional as F\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "# Define a transform to normalize the data\n",
+ "transform = transforms.Compose([transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n",
+ " ])\n",
+ "# Download and load the training data\n",
+ "trainset = datasets.MNIST('~/.pytorch/MNIST_data/', download=True, train=True, transform=transform)\n",
+ "trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Note\n",
+ "If you haven't seen `nn.Sequential` yet, please finish the end of the Part 2 notebook."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor(2.3037)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Build a feed-forward network\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",
+ "\n",
+ "# Define the loss\n",
+ "criterion = nn.CrossEntropyLoss()\n",
+ "\n",
+ "# Get our data\n",
+ "images, labels = next(iter(trainloader))\n",
+ "# Flatten images\n",
+ "images = images.view(images.shape[0], -1)\n",
+ "\n",
+ "# Forward pass, get our logits\n",
+ "logits = model(images)\n",
+ "# Calculate the loss with the logits and the labels\n",
+ "loss = criterion(logits, labels)\n",
+ "\n",
+ "print(loss)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In my experience it's more convenient to build the model with a log-softmax output using `nn.LogSoftmax` or `F.log_softmax` ([documentation](https://pytorch.org/docs/stable/nn.html#torch.nn.LogSoftmax)). Then you can get the actual probabilities by taking the exponential `torch.exp(output)`. With a log-softmax output, you want to use the negative log likelihood loss, `nn.NLLLoss` ([documentation](https://pytorch.org/docs/stable/nn.html#torch.nn.NLLLoss)).\n",
+ "\n",
+ ">**Exercise:** Build a model that returns the log-softmax as the output and calculate the loss using the negative log likelihood loss. Note that for `nn.LogSoftmax` and `F.log_softmax` you'll need to set the `dim` keyword argument appropriately. `dim=0` calculates softmax across the rows, so each column sums to 1, while `dim=1` calculates across the columns so each row sums to 1. Think about what you want the output to be and choose `dim` appropriately."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor(2.3134)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# TODO: Build a feed-forward network\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))\n",
+ "\n",
+ "# TODO: Define the loss\n",
+ "criterion = nn.NLLLoss()\n",
+ "\n",
+ "### Run this to check your work\n",
+ "# Get our data\n",
+ "images, labels = next(iter(trainloader))\n",
+ "# Flatten images\n",
+ "images = images.view(images.shape[0], -1)\n",
+ "\n",
+ "# Forward pass, get our logits\n",
+ "logits = model(images)\n",
+ "# Calculate the loss with the logits and the labels\n",
+ "loss = criterion(logits, labels)\n",
+ "\n",
+ "print(loss)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Autograd\n",
+ "\n",
+ "Now that we know how to calculate a loss, how do we use it to perform backpropagation? Torch provides a module, `autograd`, for automatically calculating the gradients of tensors. We can use it to calculate the gradients of all our parameters with respect to the loss. Autograd works by keeping track of operations performed on tensors, then going backwards through those operations, calculating gradients along the way. To make sure PyTorch keeps track of operations on a tensor and calculates the gradients, you need to set `requires_grad = True` on a tensor. You can do this at creation with the `requires_grad` keyword, or at any time with `x.requires_grad_(True)`.\n",
+ "\n",
+ "You can turn off gradients for a block of code with the `torch.no_grad()` content:\n",
+ "```python\n",
+ "x = torch.zeros(1, requires_grad=True)\n",
+ ">>> with torch.no_grad():\n",
+ "... y = x * 2\n",
+ ">>> y.requires_grad\n",
+ "False\n",
+ "```\n",
+ "\n",
+ "Also, you can turn on or off gradients altogether with `torch.set_grad_enabled(True|False)`.\n",
+ "\n",
+ "The gradients are computed with respect to some variable `z` with `z.backward()`. This does a backward pass through the operations that created `z`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[-0.1234, 1.2443],\n",
+ " [-1.2560, -0.1746]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "x = torch.randn(2,2, requires_grad=True)\n",
+ "print(x)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "tensor([[ 0.0152, 1.5482],\n",
+ " [ 1.5776, 0.0305]])\n"
+ ]
+ }
+ ],
+ "source": [
+ "y = x**2\n",
+ "print(y)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Below we can see the operation that created `y`, a power operation `PowBackward0`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "
\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": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n",
+ "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n",
+ "Processing...\n",
+ "Done!\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "from torchvision import datasets, transforms\n",
+ "import helper\n",
+ "\n",
+ "# Define a transform to normalize the data\n",
+ "transform = transforms.Compose([transforms.ToTensor(),\n",
+ " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 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": "markdown",
+ "metadata": {},
+ "source": [
+ "Here we can see one of the images."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
\n",
+ "\n",
+ "The network learns the training set better and better, resulting in lower training losses. However, it starts having problems generalizing to data outside the training set leading to the validation loss increasing. The ultimate goal of any deep learning model is to make predictions on new data, so we should strive to get the lowest validation loss possible. One option is to use the version of the model with the lowest validation loss, here the one around 8-10 training epochs. This strategy is called *early-stopping*. In practice, you'd save the model frequently as you're training then later choose the model with the lowest validation loss.\n",
+ "\n",
+ "The most common method to reduce overfitting (outside of early-stopping) is *dropout*, where we randomly drop input units. This forces the network to share information between weights, increasing it's ability to generalize to new data. Adding dropout in PyTorch is straightforward using the [`nn.Dropout`](https://pytorch.org/docs/stable/nn.html#torch.nn.Dropout) module.\n",
+ "\n",
+ "```python\n",
+ "class Classifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.fc1 = nn.Linear(784, 256)\n",
+ " self.fc2 = nn.Linear(256, 128)\n",
+ " self.fc3 = nn.Linear(128, 64)\n",
+ " self.fc4 = nn.Linear(64, 10)\n",
+ " \n",
+ " # Dropout module with 0.2 drop probability\n",
+ " self.dropout = nn.Dropout(p=0.2)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # make sure input tensor is flattened\n",
+ " x = x.view(x.shape[0], -1)\n",
+ " \n",
+ " # Now with dropout\n",
+ " x = self.dropout(F.relu(self.fc1(x)))\n",
+ " x = self.dropout(F.relu(self.fc2(x)))\n",
+ " x = self.dropout(F.relu(self.fc3(x)))\n",
+ " \n",
+ " # output so no dropout here\n",
+ " x = F.log_softmax(self.fc4(x), dim=1)\n",
+ " \n",
+ " return x\n",
+ "```\n",
+ "\n",
+ "During training we want to use dropout to prevent overfitting, but during inference we want to use the entire network. So, we need to turn off dropout during validation, testing, and whenever we're using the network to make predictions. To do this, you use `model.eval()`. This sets the model to evaluation mode where the dropout probability is 0. You can turn dropout back on by setting the model to train mode with `model.train()`. In general, the pattern for the validation loop will look like this, where you turn off gradients, set the model to evaluation mode, calculate the validation loss and metric, then set the model back to train mode.\n",
+ "\n",
+ "```python\n",
+ "# turn off gradients\n",
+ "with torch.no_grad():\n",
+ " \n",
+ " # set model to evaluation mode\n",
+ " model.eval()\n",
+ " \n",
+ " # validation pass here\n",
+ " for images, labels in testloader:\n",
+ " ...\n",
+ "\n",
+ "# set model back to train mode\n",
+ "model.train()\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "> **Exercise:** Add dropout to your model and train it on Fashion-MNIST again. See if you can get a lower validation loss or higher accuracy."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from torch import nn, optim\n",
+ "import torch.nn.functional as F\n",
+ "\n",
+ "class Classifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.fc1 = nn.Linear(784, 256)\n",
+ " self.fc2 = nn.Linear(256, 128)\n",
+ " self.fc3 = nn.Linear(128, 64)\n",
+ " self.fc4 = nn.Linear(64, 10)\n",
+ " \n",
+ " # Dropout module with 0.2 prob\n",
+ " self.dropout = nn.Dropout(p=0.2)\n",
+ " \n",
+ " def forward(self, x):\n",
+ " # make sure input tensor is flattened\n",
+ " x = x.view(x.shape[0], -1)\n",
+ " \n",
+ " # Apply dropout to inputs\n",
+ " x = self.dropout(F.relu(self.fc1(x)))\n",
+ " x = self.dropout(F.relu(self.fc2(x)))\n",
+ " x = self.dropout(F.relu(self.fc3(x)))\n",
+ " \n",
+ " # Output does not need dropout\n",
+ " x = F.log_softmax(self.fc4(x), dim=1)\n",
+ " \n",
+ " return x"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 1 out of 30\n",
+ "Training Loss: 0.615\n",
+ "Test Loss: 0.459\n",
+ "Test Accuracy: 0.836\n",
+ "Epoch: 2 out of 30\n",
+ "Training Loss: 0.484\n",
+ "Test Loss: 0.455\n",
+ "Test Accuracy: 0.844\n",
+ "Epoch: 3 out of 30\n",
+ "Training Loss: 0.455\n",
+ "Test Loss: 0.419\n",
+ "Test Accuracy: 0.846\n",
+ "Epoch: 4 out of 30\n",
+ "Training Loss: 0.436\n",
+ "Test Loss: 0.409\n",
+ "Test Accuracy: 0.856\n",
+ "Epoch: 5 out of 30\n",
+ "Training Loss: 0.416\n",
+ "Test Loss: 0.400\n",
+ "Test Accuracy: 0.857\n",
+ "Epoch: 6 out of 30\n",
+ "Training Loss: 0.414\n",
+ "Test Loss: 0.414\n",
+ "Test Accuracy: 0.853\n",
+ "Epoch: 7 out of 30\n",
+ "Training Loss: 0.406\n",
+ "Test Loss: 0.424\n",
+ "Test Accuracy: 0.853\n",
+ "Epoch: 8 out of 30\n",
+ "Training Loss: 0.408\n",
+ "Test Loss: 0.398\n",
+ "Test Accuracy: 0.866\n",
+ "Epoch: 9 out of 30\n",
+ "Training Loss: 0.395\n",
+ "Test Loss: 0.395\n",
+ "Test Accuracy: 0.868\n",
+ "Epoch: 10 out of 30\n",
+ "Training Loss: 0.387\n",
+ "Test Loss: 0.396\n",
+ "Test Accuracy: 0.854\n",
+ "Epoch: 11 out of 30\n",
+ "Training Loss: 0.384\n",
+ "Test Loss: 0.409\n",
+ "Test Accuracy: 0.862\n",
+ "Epoch: 12 out of 30\n",
+ "Training Loss: 0.380\n",
+ "Test Loss: 0.394\n",
+ "Test Accuracy: 0.864\n",
+ "Epoch: 13 out of 30\n",
+ "Training Loss: 0.382\n",
+ "Test Loss: 0.377\n",
+ "Test Accuracy: 0.870\n",
+ "Epoch: 14 out of 30\n",
+ "Training Loss: 0.372\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.869\n",
+ "Epoch: 15 out of 30\n",
+ "Training Loss: 0.382\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.867\n",
+ "Epoch: 16 out of 30\n",
+ "Training Loss: 0.374\n",
+ "Test Loss: 0.402\n",
+ "Test Accuracy: 0.861\n",
+ "Epoch: 17 out of 30\n",
+ "Training Loss: 0.368\n",
+ "Test Loss: 0.389\n",
+ "Test Accuracy: 0.870\n",
+ "Epoch: 18 out of 30\n",
+ "Training Loss: 0.368\n",
+ "Test Loss: 0.367\n",
+ "Test Accuracy: 0.869\n",
+ "Epoch: 19 out of 30\n",
+ "Training Loss: 0.363\n",
+ "Test Loss: 0.382\n",
+ "Test Accuracy: 0.871\n",
+ "Epoch: 20 out of 30\n",
+ "Training Loss: 0.361\n",
+ "Test Loss: 0.414\n",
+ "Test Accuracy: 0.863\n",
+ "Epoch: 21 out of 30\n",
+ "Training Loss: 0.368\n",
+ "Test Loss: 0.386\n",
+ "Test Accuracy: 0.866\n",
+ "Epoch: 22 out of 30\n",
+ "Training Loss: 0.358\n",
+ "Test Loss: 0.380\n",
+ "Test Accuracy: 0.876\n",
+ "Epoch: 23 out of 30\n",
+ "Training Loss: 0.351\n",
+ "Test Loss: 0.383\n",
+ "Test Accuracy: 0.866\n",
+ "Epoch: 24 out of 30\n",
+ "Training Loss: 0.353\n",
+ "Test Loss: 0.389\n",
+ "Test Accuracy: 0.868\n",
+ "Epoch: 25 out of 30\n",
+ "Training Loss: 0.351\n",
+ "Test Loss: 0.379\n",
+ "Test Accuracy: 0.864\n",
+ "Epoch: 26 out of 30\n",
+ "Training Loss: 0.354\n",
+ "Test Loss: 0.385\n",
+ "Test Accuracy: 0.873\n",
+ "Epoch: 27 out of 30\n",
+ "Training Loss: 0.350\n",
+ "Test Loss: 0.385\n",
+ "Test Accuracy: 0.871\n",
+ "Epoch: 28 out of 30\n",
+ "Training Loss: 0.350\n",
+ "Test Loss: 0.370\n",
+ "Test Accuracy: 0.876\n",
+ "Epoch: 29 out of 30\n",
+ "Training Loss: 0.346\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.869\n",
+ "Epoch: 30 out of 30\n",
+ "Training Loss: 0.338\n",
+ "Test Loss: 0.391\n",
+ "Test Accuracy: 0.872\n"
+ ]
+ }
+ ],
+ "source": [
+ "model = Classifier()\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.Adam(model.parameters(), lr=0.003)\n",
+ "\n",
+ "epochs = 30\n",
+ "steps = 0\n",
+ "\n",
+ "trainLosses, testLosses = [], []\n",
+ "for e in range(epochs):\n",
+ " runningLoss = 0\n",
+ " for images, labels in trainloader:\n",
+ " \n",
+ " optimizer.zero_grad()\n",
+ " \n",
+ " log_ps = model(images)\n",
+ " loss = criterion(log_ps, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ " \n",
+ " runningLoss += loss.item()\n",
+ " \n",
+ " else:\n",
+ " ## TODO: Implement the validation pass and print out the validation accuracy\n",
+ " testLoss = 0\n",
+ " accuracy = 0\n",
+ " \n",
+ " # Turn off gradients for validation step\n",
+ " with torch.no_grad():\n",
+ " \n",
+ " # Set model to evaluation mode\n",
+ " model.eval()\n",
+ " \n",
+ " for images, labels in testloader:\n",
+ " # Get the output\n",
+ " log_ps = model(images)\n",
+ " # Get the loss\n",
+ " testLoss += criterion(log_ps, labels)\n",
+ " \n",
+ " # Get the probabilities\n",
+ " ps = torch.exp(log_ps)\n",
+ " # Get the most likely class for each prediction\n",
+ " top_p, top_class = ps.topk(1, dim=1)\n",
+ " # Check if the predictions match the actual label\n",
+ " equals = top_class == labels.view(*top_class.shape)\n",
+ " # Update accuracy\n",
+ " accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
+ " \n",
+ " # Update train loss\n",
+ " trainLosses.append(runningLoss/len(trainloader))\n",
+ " # Update test loss\n",
+ " testLosses.append(testLoss/len(testloader))\n",
+ " \n",
+ " # Set model back to train mode\n",
+ " model.train()\n",
+ " \n",
+ " # Print output\n",
+ " print(f'Epoch: {e+1} out of {epochs}')\n",
+ " print(f'Training Loss: {runningLoss/len(trainloader):.3f}')\n",
+ " print(f'Test Loss: {testLoss/len(testloader):.3f}')\n",
+ " print(f'Test Accuracy: {accuracy/len(testloader):.3f}')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 36,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "
\n",
+ "\n",
+ "We'll use this dataset to train a neural network that can differentiate between cats and dogs. These days it doesn't seem like a big accomplishment, but five years ago it was a serious challenge for computer vision systems."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import torch\n",
+ "from torchvision import datasets, transforms\n",
+ "\n",
+ "import helper"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The easiest way to load image data is with `datasets.ImageFolder` from `torchvision` ([documentation](http://pytorch.org/docs/master/torchvision/datasets.html#imagefolder)). In general you'll use `ImageFolder` like so:\n",
+ "\n",
+ "```python\n",
+ "dataset = datasets.ImageFolder('path/to/data', transform=transform)\n",
+ "```\n",
+ "\n",
+ "where `'path/to/data'` is the file path to the data directory and `transform` is a list of processing steps built with the [`transforms`](http://pytorch.org/docs/master/torchvision/transforms.html) module from `torchvision`. ImageFolder expects the files and directories to be constructed like so:\n",
+ "```\n",
+ "root/dog/xxx.png\n",
+ "root/dog/xxy.png\n",
+ "root/dog/xxz.png\n",
+ "\n",
+ "root/cat/123.png\n",
+ "root/cat/nsdf3.png\n",
+ "root/cat/asd932_.png\n",
+ "```\n",
+ "\n",
+ "where each class has it's own directory (`cat` and `dog`) for the images. The images are then labeled with the class taken from the directory name. So here, the image `123.png` would be loaded with the class label `cat`. You can download the dataset already structured like this [from here](https://s3.amazonaws.com/content.udacity-data.com/nd089/Cat_Dog_data.zip). I've also split it into a training set and test set.\n",
+ "\n",
+ "### Transforms\n",
+ "\n",
+ "When you load in the data with `ImageFolder`, you'll need to define some transforms. For example, the images are different sizes but we'll need them to all be the same size for training. You can either resize them with `transforms.Resize()` or crop with `transforms.CenterCrop()`, `transforms.RandomResizedCrop()`, etc. We'll also need to convert the images to PyTorch tensors with `transforms.ToTensor()`. Typically you'll combine these transforms into a pipeline with `transforms.Compose()`, which accepts a list of transforms and runs them in sequence. It looks something like this to scale, then crop, then convert to a tensor:\n",
+ "\n",
+ "```python\n",
+ "transform = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor()])\n",
+ "\n",
+ "```\n",
+ "\n",
+ "There are plenty of transforms available, I'll cover more in a bit and you can read through the [documentation](http://pytorch.org/docs/master/torchvision/transforms.html). \n",
+ "\n",
+ "### Data Loaders\n",
+ "\n",
+ "With the `ImageFolder` loaded, you have to pass it to a [`DataLoader`](http://pytorch.org/docs/master/data.html#torch.utils.data.DataLoader). The `DataLoader` takes a dataset (such as you would get from `ImageFolder`) and returns batches of images and the corresponding labels. You can set various parameters like the batch size and if the data is shuffled after each epoch.\n",
+ "\n",
+ "```python\n",
+ "dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)\n",
+ "```\n",
+ "\n",
+ "Here `dataloader` is a [generator](https://jeffknupp.com/blog/2013/04/07/improve-your-python-yield-and-generators-explained/). To get data out of it, you need to loop through it or convert it to an iterator and call `next()`.\n",
+ "\n",
+ "```python\n",
+ "# Looping through it, get a batch on each loop \n",
+ "for images, labels in dataloader:\n",
+ " pass\n",
+ "\n",
+ "# Get one batch\n",
+ "images, labels = next(iter(dataloader))\n",
+ "```\n",
+ " \n",
+ ">**Exercise:** Load images from the `Cat_Dog_data/train` folder, define a few transforms, then build the dataloader."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_dir = 'Cat_Dog_data/train'\n",
+ "\n",
+ "transform = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor()])\n",
+ "dataset = datasets.ImageFolder(data_dir, transform=transform)\n",
+ "dataloader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Data Augmentation\n",
+ "\n",
+ "A common strategy for training neural networks is to introduce randomness in the input data itself. For example, you can randomly rotate, mirror, scale, and/or crop your images during training. This will help your network generalize as it's seeing the same images but in different locations, with different sizes, in different orientations, etc.\n",
+ "\n",
+ "To randomly rotate, scale and crop, then flip your images you would define your transforms like this:\n",
+ "\n",
+ "```python\n",
+ "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n",
+ " transforms.RandomResizedCrop(224),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.5, 0.5, 0.5], \n",
+ " [0.5, 0.5, 0.5])])\n",
+ "```\n",
+ "\n",
+ "You'll also typically want to normalize images with `transforms.Normalize`. You pass in a list of means and list of standard deviations, then the color channels are normalized like so\n",
+ "\n",
+ "```input[channel] = (input[channel] - mean[channel]) / std[channel]```\n",
+ "\n",
+ "Subtracting `mean` centers the data around zero and dividing by `std` squishes the values to be between -1 and 1. Normalizing helps keep the network work weights near zero which in turn makes backpropagation more stable. Without normalization, networks will tend to fail to learn.\n",
+ "\n",
+ "You can find a list of all [the available transforms here](http://pytorch.org/docs/0.3.0/torchvision/transforms.html). When you're testing however, you'll want to use images that aren't altered (except you'll need to normalize the same way). So, for validation/test images, you'll typically just resize and crop.\n",
+ "\n",
+ ">**Exercise:** Define transforms for training data and testing data below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 39,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_dir = 'Cat_Dog_data'\n",
+ "\n",
+ "# TODO: Define transforms for the training data and testing data\n",
+ "# TODO: Define transforms for the training data and testing data\n",
+ "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n",
+ " transforms.RandomResizedCrop(224),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor()]) \n",
+ "\n",
+ "test_transforms = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor()])\n",
+ "\n",
+ "\n",
+ "# Pass transforms in here, then run the next cell to see how the transforms look\n",
+ "train_data = datasets.ImageFolder(data_dir + '/train', transform=train_transforms)\n",
+ "test_data = datasets.ImageFolder(data_dir + '/test', transform=test_transforms)\n",
+ "\n",
+ "trainloader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True)\n",
+ "testloader = torch.utils.data.DataLoader(test_data, batch_size=32)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 43,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "
\n",
+ "\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "At this point you should be able to load data for training and testing. Now, you should try building a network that can classify cats vs dogs. This is quite a bit more complicated than before with the MNIST and Fashion-MNIST datasets. To be honest, you probably won't get it to work with a fully-connected network, no matter how deep. These images have three color channels and at a higher resolution (so far you've seen 28x28 images which are tiny).\n",
+ "\n",
+ "In the next part, I'll show you how to use a pre-trained network to build a model that can actually solve this problem."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Optional TODO: Attempt to build a network to classify cats vs dogs from this dataset"
+ ]
+ }
+ ],
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Exercises).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Exercises).ipynb
new file mode 100644
index 0000000..7ecb3a5
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Exercises).ipynb
@@ -0,0 +1,903 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Transfer Learning\n",
+ "\n",
+ "In this notebook, you'll learn how to use pre-trained networks to solved challenging problems in computer vision. Specifically, you'll use networks trained on [ImageNet](http://www.image-net.org/) [available from torchvision](http://pytorch.org/docs/0.3.0/torchvision/models.html). \n",
+ "\n",
+ "ImageNet is a massive dataset with over 1 million labeled images in 1000 categories. It's used to train deep neural networks using an architecture called convolutional layers. I'm not going to get into the details of convolutional networks here, but if you want to learn more about them, please [watch this](https://www.youtube.com/watch?v=2-Ol7ZB0MmU).\n",
+ "\n",
+ "Once trained, these models work astonishingly well as feature detectors for images they weren't trained on. Using a pre-trained network on images not in the training set is called transfer learning. Here we'll use transfer learning to train a network that can classify our cat and dog photos with near perfect accuracy.\n",
+ "\n",
+ "With `torchvision.models` you can download these pre-trained networks and use them in your applications. We'll include `models` in our imports now."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import torch\n",
+ "from torch import nn\n",
+ "from torch import optim\n",
+ "import torch.nn.functional as F\n",
+ "from torchvision import datasets, transforms, models"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Most of the pretrained models require the input to be 224x224 images. Also, we'll need to match the normalization used when the models were trained. Each color channel was normalized separately, the means are `[0.485, 0.456, 0.406]` and the standard deviations are `[0.229, 0.224, 0.225]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_dir = 'Cat_Dog_data'\n",
+ "\n",
+ "# TODO: Define transforms for the training data and testing data\n",
+ "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n",
+ " transforms.RandomResizedCrop(224),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406],\n",
+ " [0.229, 0.224, 0.225])])\n",
+ "\n",
+ "test_transforms = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406],\n",
+ " [0.229, 0.224, 0.225])])\n",
+ "\n",
+ "# Pass transforms in here, then run the next cell to see how the transforms look\n",
+ "train_data = datasets.ImageFolder(data_dir + '/train', transform=train_transforms)\n",
+ "test_data = datasets.ImageFolder(data_dir + '/test', transform=test_transforms)\n",
+ "\n",
+ "trainloader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)\n",
+ "testloader = torch.utils.data.DataLoader(test_data, batch_size=64)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can load in a model such as [DenseNet](http://pytorch.org/docs/0.3.0/torchvision/models.html#id5). Let's print out the model architecture so we can see what's going on."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/conda/lib/python3.6/site-packages/torchvision-0.2.1-py3.6.egg/torchvision/models/densenet.py:212: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "DenseNet(\n",
+ " (features): Sequential(\n",
+ " (conv0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+ " (norm0): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu0): ReLU(inplace)\n",
+ " (pool0): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+ " (denseblock1): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(96, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition1): _Transition(\n",
+ " (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock2): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition2): _Transition(\n",
+ " (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock3): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer13): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer14): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer15): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer16): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer17): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer18): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer19): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer20): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer21): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer22): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer23): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer24): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition3): _Transition(\n",
+ " (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock4): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer13): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer14): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer15): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer16): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (norm5): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " (classifier): Linear(in_features=1024, out_features=1000, bias=True)\n",
+ ")"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model = models.densenet121(pretrained=True)\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This model is built out of two main parts, the features and the classifier. The features part is a stack of convolutional layers and overall works as a feature detector that can be fed into a classifier. The classifier part is a single fully-connected layer `(classifier): Linear(in_features=1024, out_features=1000)`. This layer was trained on the ImageNet dataset, so it won't work for our specific problem. That means we need to replace the classifier, but the features will work perfectly on their own. In general, I think about pre-trained networks as amazingly good feature detectors that can be used as the input for simple feed-forward classifiers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Freeze parameters so we don't backprop through them\n",
+ "for param in model.parameters():\n",
+ " param.requires_grad = False\n",
+ "\n",
+ "from collections import OrderedDict\n",
+ "classifier = nn.Sequential(OrderedDict([\n",
+ " ('fc1', nn.Linear(1024, 500)),\n",
+ " ('relu', nn.ReLU()),\n",
+ " ('fc2', nn.Linear(500, 2)),\n",
+ " ('output', nn.LogSoftmax(dim=1))\n",
+ " ]))\n",
+ " \n",
+ "model.classifier = classifier"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "With our model built, we need to train the classifier. However, now we're using a **really deep** neural network. If you try to train this on a CPU like normal, it will take a long, long time. Instead, we're going to use the GPU to do the calculations. The linear algebra computations are done in parallel on the GPU leading to 100x increased training speeds. It's also possible to train on multiple GPUs, further decreasing training time.\n",
+ "\n",
+ "PyTorch, along with pretty much every other deep learning framework, uses [CUDA](https://developer.nvidia.com/cuda-zone) to efficiently compute the forward and backwards passes on the GPU. In PyTorch, you move your model parameters and other tensors to the GPU memory using `model.to('cuda')`. You can move them back from the GPU with `model.to('cpu')` which you'll commonly do when you need to operate on the network output outside of PyTorch. As a demonstration of the increased speed, I'll compare how long it takes to perform a forward and backward pass with and without a GPU."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Device = cpu; Time per batch: 5.701 seconds\n",
+ "Device = cuda; Time per batch: 0.010 seconds\n"
+ ]
+ }
+ ],
+ "source": [
+ "for device in ['cpu', 'cuda']:\n",
+ "\n",
+ " criterion = nn.NLLLoss()\n",
+ " # Only train the classifier parameters, feature parameters are frozen\n",
+ " optimizer = optim.Adam(model.classifier.parameters(), lr=0.001)\n",
+ "\n",
+ " model.to(device)\n",
+ "\n",
+ " for ii, (inputs, labels) in enumerate(trainloader):\n",
+ "\n",
+ " # Move input and label tensors to the GPU\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ "\n",
+ " start = time.time()\n",
+ "\n",
+ " outputs = model.forward(inputs)\n",
+ " loss = criterion(outputs, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " if ii==3:\n",
+ " break\n",
+ " \n",
+ " print(f\"Device = {device}; Time per batch: {(time.time() - start)/3:.3f} seconds\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can write device agnostic code which will automatically use CUDA if it's enabled like so:\n",
+ "```python\n",
+ "# at beginning of the script\n",
+ "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+ "\n",
+ "...\n",
+ "\n",
+ "# then whenever you get a new Tensor or Module\n",
+ "# this won't copy if they are already on the desired device\n",
+ "input = data.to(device)\n",
+ "model = MyModule(...).to(device)\n",
+ "```\n",
+ "\n",
+ "From here, I'll let you finish training the model. The process is the same as before except now your model is much more powerful. You should get better than 95% accuracy easily.\n",
+ "\n",
+ ">**Exercise:** Train a pretrained models to classify the cat and dog images. Continue with the DenseNet model, or try ResNet, it's also a good model to try out first. Make sure you are only training the classifier and the parameters for the features part are frozen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/conda/lib/python3.6/site-packages/torchvision-0.2.1-py3.6.egg/torchvision/models/densenet.py:212: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "device(type='cuda')"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "## TODO: Use a pretrained model to classify the cat and dog images\n",
+ "\n",
+ "# Use GPU if it's available\n",
+ "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+ "\n",
+ "model = models.densenet121(pretrained=True)\n",
+ "\n",
+ "# Freeze Parameters so we don't back propagate through them\n",
+ "for param in model.parameters():\n",
+ " param.requires_grad = False\n",
+ " \n",
+ "model.classifier = nn.Sequential(nn.Linear(1024, 256),\n",
+ " nn.ReLU(),\n",
+ " nn.Dropout(0.2),\n",
+ " nn.Linear(256, 2),\n",
+ " nn.LogSoftmax(dim=1))\n",
+ "\n",
+ "criterion = nn.NLLLoss()\n",
+ "\n",
+ "# Only train the classifier parameters, feature parameters are frozen\n",
+ "optimizer = optim.Adam(model.classifier.parameters(), lr=0.003)\n",
+ "\n",
+ "model.to(device)\n",
+ "device"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch: 1 out of 1\n",
+ "Training Loss: 0.208\n",
+ "Test Loss: 0.076\n",
+ "Test Accuracy: 0.971\n",
+ "\n",
+ "Epoch: 1 out of 1\n",
+ "Training Loss: 0.214\n",
+ "Test Loss: 0.068\n",
+ "Test Accuracy: 0.978\n",
+ "\n",
+ "Epoch: 1 out of 1\n",
+ "Training Loss: 0.216\n",
+ "Test Loss: 0.075\n",
+ "Test Accuracy: 0.971\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "epochs = 1\n",
+ "steps = 0\n",
+ "runningLoss = 0\n",
+ "printEvery = 5\n",
+ "\n",
+ "for epoch in range(epochs):\n",
+ " for inputs, labels in trainloader:\n",
+ " steps += 1\n",
+ " \n",
+ " # Move input and label tensors to the device\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ " \n",
+ " # Zero the gradients\n",
+ " optimizer.zero_grad()\n",
+ " \n",
+ " # Make forward pass\n",
+ " logps = model.forward(inputs)\n",
+ " \n",
+ " # Calculate loss\n",
+ " loss = criterion(logps, labels)\n",
+ " \n",
+ " # Backpropagate\n",
+ " loss.backward()\n",
+ " \n",
+ " # Update the weights\n",
+ " optimizer.step()\n",
+ " \n",
+ " runningLoss += loss.item()\n",
+ " \n",
+ " # Do the validation pass\n",
+ " if steps % printEvery == 0:\n",
+ " testLoss = 0\n",
+ " accuracy = 0\n",
+ " model.eval()\n",
+ " \n",
+ " with torch.no_grad():\n",
+ " for inputs, labels in testloader:\n",
+ " # Move input and label tensors to the device\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ " \n",
+ " # Get the output\n",
+ " logps = model.forward(inputs)\n",
+ " \n",
+ " # Get the loss\n",
+ " batchLoss = criterion(logps, labels)\n",
+ " testLoss += batchLoss.item()\n",
+ " \n",
+ " # Find the accuracy\n",
+ " # Get the probabilities\n",
+ " ps = torch.exp(logps)\n",
+ " \n",
+ " # Get the most likely class for each prediction\n",
+ " top_p, top_class = ps.topk(1, dim=1)\n",
+ " \n",
+ " # Check if the predictions match the actual label\n",
+ " equals = top_class == labels.view(*top_class.shape)\n",
+ " \n",
+ " # Update accuracy\n",
+ " accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
+ " \n",
+ " # Print output\n",
+ " print(f'Epoch: {epoch+1} out of {epochs}')\n",
+ " print(f'Training Loss: {runningLoss/printEvery:.3f}')\n",
+ " print(f'Test Loss: {testLoss/len(testloader):.3f}')\n",
+ " print(f'Test Accuracy: {accuracy/len(testloader):.3f}')\n",
+ " print()\n",
+ "\n",
+ " runningLoss = 0\n",
+ " model.train()"
+ ]
+ },
+ {
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Solution).ipynb b/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Solution).ipynb
new file mode 100644
index 0000000..fe32747
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Part 8 - Transfer Learning (Solution).ipynb
@@ -0,0 +1,861 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Transfer Learning\n",
+ "\n",
+ "In this notebook, you'll learn how to use pre-trained networks to solved challenging problems in computer vision. Specifically, you'll use networks trained on [ImageNet](http://www.image-net.org/) [available from torchvision](http://pytorch.org/docs/0.3.0/torchvision/models.html). \n",
+ "\n",
+ "ImageNet is a massive dataset with over 1 million labeled images in 1000 categories. It's used to train deep neural networks using an architecture called convolutional layers. I'm not going to get into the details of convolutional networks here, but if you want to learn more about them, please [watch this](https://www.youtube.com/watch?v=2-Ol7ZB0MmU).\n",
+ "\n",
+ "Once trained, these models work astonishingly well as feature detectors for images they weren't trained on. Using a pre-trained network on images not in the training set is called transfer learning. Here we'll use transfer learning to train a network that can classify our cat and dog photos with near perfect accuracy.\n",
+ "\n",
+ "With `torchvision.models` you can download these pre-trained networks and use them in your applications. We'll include `models` in our imports now."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%matplotlib inline\n",
+ "%config InlineBackend.figure_format = 'retina'\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "import torch\n",
+ "from torch import nn\n",
+ "from torch import optim\n",
+ "import torch.nn.functional as F\n",
+ "from torchvision import datasets, transforms, models"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Most of the pretrained models require the input to be 224x224 images. Also, we'll need to match the normalization used when the models were trained. Each color channel was normalized separately, the means are `[0.485, 0.456, 0.406]` and the standard deviations are `[0.229, 0.224, 0.225]`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "data_dir = 'Cat_Dog_data'\n",
+ "\n",
+ "# TODO: Define transforms for the training data and testing data\n",
+ "train_transforms = transforms.Compose([transforms.RandomRotation(30),\n",
+ " transforms.RandomResizedCrop(224),\n",
+ " transforms.RandomHorizontalFlip(),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406],\n",
+ " [0.229, 0.224, 0.225])])\n",
+ "\n",
+ "test_transforms = transforms.Compose([transforms.Resize(255),\n",
+ " transforms.CenterCrop(224),\n",
+ " transforms.ToTensor(),\n",
+ " transforms.Normalize([0.485, 0.456, 0.406],\n",
+ " [0.229, 0.224, 0.225])])\n",
+ "\n",
+ "# Pass transforms in here, then run the next cell to see how the transforms look\n",
+ "train_data = datasets.ImageFolder(data_dir + '/train', transform=train_transforms)\n",
+ "test_data = datasets.ImageFolder(data_dir + '/test', transform=test_transforms)\n",
+ "\n",
+ "trainloader = torch.utils.data.DataLoader(train_data, batch_size=64, shuffle=True)\n",
+ "testloader = torch.utils.data.DataLoader(test_data, batch_size=64)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "We can load in a model such as [DenseNet](http://pytorch.org/docs/0.3.0/torchvision/models.html#id5). Let's print out the model architecture so we can see what's going on."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/conda/lib/python3.6/site-packages/torchvision-0.2.1-py3.6.egg/torchvision/models/densenet.py:212: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "DenseNet(\n",
+ " (features): Sequential(\n",
+ " (conv0): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
+ " (norm0): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu0): ReLU(inplace)\n",
+ " (pool0): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
+ " (denseblock1): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(96, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition1): _Transition(\n",
+ " (norm): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock2): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(160, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(160, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(192, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(192, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(224, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(224, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition2): _Transition(\n",
+ " (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock3): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(288, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(288, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(320, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(352, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(352, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(384, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(384, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(416, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(416, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(448, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(448, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(480, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(480, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer13): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer14): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer15): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer16): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer17): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer18): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer19): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer20): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer21): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer22): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer23): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer24): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (transition3): _Transition(\n",
+ " (norm): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu): ReLU(inplace)\n",
+ " (conv): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (pool): AvgPool2d(kernel_size=2, stride=2, padding=0)\n",
+ " )\n",
+ " (denseblock4): _DenseBlock(\n",
+ " (denselayer1): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer2): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(544, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(544, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer3): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(576, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(576, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer4): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(608, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(608, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer5): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(640, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(640, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer6): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(672, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(672, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer7): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(704, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(704, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer8): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(736, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(736, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer9): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(768, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(768, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer10): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(800, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(800, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer11): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(832, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(832, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer12): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(864, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(864, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer13): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(896, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(896, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer14): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(928, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(928, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer15): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(960, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(960, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " (denselayer16): _DenseLayer(\n",
+ " (norm1): BatchNorm2d(992, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu1): ReLU(inplace)\n",
+ " (conv1): Conv2d(992, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
+ " (norm2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " (relu2): ReLU(inplace)\n",
+ " (conv2): Conv2d(128, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
+ " )\n",
+ " )\n",
+ " (norm5): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
+ " )\n",
+ " (classifier): Linear(in_features=1024, out_features=1000, bias=True)\n",
+ ")"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "model = models.densenet121(pretrained=True)\n",
+ "model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This model is built out of two main parts, the features and the classifier. The features part is a stack of convolutional layers and overall works as a feature detector that can be fed into a classifier. The classifier part is a single fully-connected layer `(classifier): Linear(in_features=1024, out_features=1000)`. This layer was trained on the ImageNet dataset, so it won't work for our specific problem. That means we need to replace the classifier, but the features will work perfectly on their own. In general, I think about pre-trained networks as amazingly good feature detectors that can be used as the input for simple feed-forward classifiers."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Freeze parameters so we don't backprop through them\n",
+ "for param in model.parameters():\n",
+ " param.requires_grad = False\n",
+ "\n",
+ "from collections import OrderedDict\n",
+ "classifier = nn.Sequential(OrderedDict([\n",
+ " ('fc1', nn.Linear(1024, 500)),\n",
+ " ('relu', nn.ReLU()),\n",
+ " ('fc2', nn.Linear(500, 2)),\n",
+ " ('output', nn.LogSoftmax(dim=1))\n",
+ " ]))\n",
+ " \n",
+ "model.classifier = classifier"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "With our model built, we need to train the classifier. However, now we're using a **really deep** neural network. If you try to train this on a CPU like normal, it will take a long, long time. Instead, we're going to use the GPU to do the calculations. The linear algebra computations are done in parallel on the GPU leading to 100x increased training speeds. It's also possible to train on multiple GPUs, further decreasing training time.\n",
+ "\n",
+ "PyTorch, along with pretty much every other deep learning framework, uses [CUDA](https://developer.nvidia.com/cuda-zone) to efficiently compute the forward and backwards passes on the GPU. In PyTorch, you move your model parameters and other tensors to the GPU memory using `model.to('cuda')`. You can move them back from the GPU with `model.to('cpu')` which you'll commonly do when you need to operate on the network output outside of PyTorch. As a demonstration of the increased speed, I'll compare how long it takes to perform a forward and backward pass with and without a GPU."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import time"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Device = cpu; Time per batch: 5.634 seconds\n",
+ "Device = cuda; Time per batch: 0.010 seconds\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Try to replace with just ['cuda'] if you are using GPU \n",
+ "\n",
+ "for device in ['cpu', 'cuda']:\n",
+ "\n",
+ " criterion = nn.NLLLoss()\n",
+ " # Only train the classifier parameters, feature parameters are frozen\n",
+ " optimizer = optim.Adam(model.classifier.parameters(), lr=0.001)\n",
+ "\n",
+ " model.to(device)\n",
+ "\n",
+ " for ii, (inputs, labels) in enumerate(trainloader):\n",
+ "\n",
+ " # Move input and label tensors to the GPU\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ "\n",
+ " start = time.time()\n",
+ "\n",
+ " outputs = model.forward(inputs)\n",
+ " loss = criterion(outputs, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " if ii==3:\n",
+ " break\n",
+ " \n",
+ " print(f\"Device = {device}; Time per batch: {(time.time() - start)/3:.3f} seconds\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "You can write device agnostic code which will automatically use CUDA if it's enabled like so:\n",
+ "```python\n",
+ "# at beginning of the script\n",
+ "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+ "\n",
+ "...\n",
+ "\n",
+ "# then whenever you get a new Tensor or Module\n",
+ "# this won't copy if they are already on the desired device\n",
+ "input = data.to(device)\n",
+ "model = MyModule(...).to(device)\n",
+ "```\n",
+ "\n",
+ "From here, I'll let you finish training the model. The process is the same as before except now your model is much more powerful. You should get better than 95% accuracy easily.\n",
+ "\n",
+ ">**Exercise:** Train a pretrained models to classify the cat and dog images. Continue with the DenseNet model, or try ResNet, it's also a good model to try out first. Make sure you are only training the classifier and the parameters for the features part are frozen."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/opt/conda/lib/python3.6/site-packages/torchvision-0.2.1-py3.6.egg/torchvision/models/densenet.py:212: UserWarning: nn.init.kaiming_normal is now deprecated in favor of nn.init.kaiming_normal_.\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Use GPU if it's available\n",
+ "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+ "\n",
+ "model = models.densenet121(pretrained=True)\n",
+ "\n",
+ "# Freeze parameters so we don't backprop through them\n",
+ "for param in model.parameters():\n",
+ " param.requires_grad = False\n",
+ " \n",
+ "model.classifier = nn.Sequential(nn.Linear(1024, 256),\n",
+ " nn.ReLU(),\n",
+ " nn.Dropout(0.2),\n",
+ " nn.Linear(256, 2),\n",
+ " nn.LogSoftmax(dim=1))\n",
+ "\n",
+ "criterion = nn.NLLLoss()\n",
+ "\n",
+ "# Only train the classifier parameters, feature parameters are frozen\n",
+ "optimizer = optim.Adam(model.classifier.parameters(), lr=0.003)\n",
+ "\n",
+ "model.to(device);"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Epoch 1/1.. Train loss: 0.844.. Test loss: 0.479.. Test accuracy: 0.675\n",
+ "Epoch 1/1.. Train loss: 0.596.. Test loss: 0.331.. Test accuracy: 0.841\n",
+ "Epoch 1/1.. Train loss: 0.314.. Test loss: 0.183.. Test accuracy: 0.939\n",
+ "Epoch 1/1.. Train loss: 0.287.. Test loss: 0.108.. Test accuracy: 0.966\n",
+ "Epoch 1/1.. Train loss: 0.241.. Test loss: 0.091.. Test accuracy: 0.969\n",
+ "Epoch 1/1.. Train loss: 0.210.. Test loss: 0.111.. Test accuracy: 0.959\n",
+ "Epoch 1/1.. Train loss: 0.192.. Test loss: 0.083.. Test accuracy: 0.969\n",
+ "Epoch 1/1.. Train loss: 0.168.. Test loss: 0.076.. Test accuracy: 0.973\n",
+ "Epoch 1/1.. Train loss: 0.176.. Test loss: 0.060.. Test accuracy: 0.979\n",
+ "Epoch 1/1.. Train loss: 0.174.. Test loss: 0.087.. Test accuracy: 0.965\n",
+ "Epoch 1/1.. Train loss: 0.167.. Test loss: 0.100.. Test accuracy: 0.960\n",
+ "Epoch 1/1.. Train loss: 0.243.. Test loss: 0.052.. Test accuracy: 0.980\n",
+ "Epoch 1/1.. Train loss: 0.252.. Test loss: 0.054.. Test accuracy: 0.982\n",
+ "Epoch 1/1.. Train loss: 0.207.. Test loss: 0.054.. Test accuracy: 0.982\n",
+ "Epoch 1/1.. Train loss: 0.199.. Test loss: 0.068.. Test accuracy: 0.979\n",
+ "Epoch 1/1.. Train loss: 0.200.. Test loss: 0.085.. Test accuracy: 0.969\n",
+ "Epoch 1/1.. Train loss: 0.196.. Test loss: 0.052.. Test accuracy: 0.982\n"
+ ]
+ }
+ ],
+ "source": [
+ "epochs = 1\n",
+ "steps = 0\n",
+ "running_loss = 0\n",
+ "print_every = 5\n",
+ "for epoch in range(epochs):\n",
+ " for inputs, labels in trainloader:\n",
+ " steps += 1\n",
+ " # Move input and label tensors to the default device\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ " \n",
+ " optimizer.zero_grad()\n",
+ " \n",
+ " logps = model.forward(inputs)\n",
+ " loss = criterion(logps, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " running_loss += loss.item()\n",
+ " \n",
+ " if steps % print_every == 0:\n",
+ " test_loss = 0\n",
+ " accuracy = 0\n",
+ " model.eval()\n",
+ " with torch.no_grad():\n",
+ " for inputs, labels in testloader:\n",
+ " inputs, labels = inputs.to(device), labels.to(device)\n",
+ " logps = model.forward(inputs)\n",
+ " batch_loss = criterion(logps, labels)\n",
+ " \n",
+ " test_loss += batch_loss.item()\n",
+ " \n",
+ " # Calculate accuracy\n",
+ " ps = torch.exp(logps)\n",
+ " top_p, top_class = ps.topk(1, dim=1)\n",
+ " equals = top_class == labels.view(*top_class.shape)\n",
+ " accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
+ " \n",
+ " print(f\"Epoch {epoch+1}/{epochs}.. \"\n",
+ " f\"Train loss: {running_loss/print_every:.3f}.. \"\n",
+ " f\"Test loss: {test_loss/len(testloader):.3f}.. \"\n",
+ " f\"Test accuracy: {accuracy/len(testloader):.3f}\")\n",
+ " running_loss = 0\n",
+ " model.train()"
+ ]
+ },
+ {
+ "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.6.3"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/Untitled.ipynb b/python/Deep Learning/Deep Learning with PyTorch/Untitled.ipynb
new file mode 100644
index 0000000..08ec6ba
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/Untitled.ipynb
@@ -0,0 +1,332 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "torch.Size([64, 10])\n",
+ "tensor([[9],\n",
+ " [9],\n",
+ " [9],\n",
+ " [9],\n",
+ " [9],\n",
+ " [5],\n",
+ " [9],\n",
+ " [5],\n",
+ " [2],\n",
+ " [9]])\n",
+ "Accuracy: 1.5625%\n",
+ "Epoch: 1 out of 30\n",
+ "Training Loss: 0.510\n",
+ "Test Loss: 0.454\n",
+ "Test Accuracy: 0.836\n",
+ "\n",
+ "Epoch: 2 out of 30\n",
+ "Training Loss: 0.389\n",
+ "Test Loss: 0.412\n",
+ "Test Accuracy: 0.852\n",
+ "\n",
+ "Epoch: 3 out of 30\n",
+ "Training Loss: 0.353\n",
+ "Test Loss: 0.388\n",
+ "Test Accuracy: 0.861\n",
+ "\n",
+ "Epoch: 4 out of 30\n",
+ "Training Loss: 0.330\n",
+ "Test Loss: 0.428\n",
+ "Test Accuracy: 0.847\n",
+ "\n",
+ "Epoch: 5 out of 30\n",
+ "Training Loss: 0.315\n",
+ "Test Loss: 0.381\n",
+ "Test Accuracy: 0.865\n",
+ "\n",
+ "Epoch: 6 out of 30\n",
+ "Training Loss: 0.303\n",
+ "Test Loss: 0.388\n",
+ "Test Accuracy: 0.864\n",
+ "\n",
+ "Epoch: 7 out of 30\n",
+ "Training Loss: 0.292\n",
+ "Test Loss: 0.364\n",
+ "Test Accuracy: 0.872\n",
+ "\n",
+ "Epoch: 8 out of 30\n",
+ "Training Loss: 0.281\n",
+ "Test Loss: 0.370\n",
+ "Test Accuracy: 0.869\n",
+ "\n",
+ "Epoch: 9 out of 30\n",
+ "Training Loss: 0.270\n",
+ "Test Loss: 0.365\n",
+ "Test Accuracy: 0.877\n",
+ "\n",
+ "Epoch: 10 out of 30\n",
+ "Training Loss: 0.267\n",
+ "Test Loss: 0.366\n",
+ "Test Accuracy: 0.877\n",
+ "\n",
+ "Epoch: 11 out of 30\n",
+ "Training Loss: 0.260\n",
+ "Test Loss: 0.369\n",
+ "Test Accuracy: 0.873\n",
+ "\n",
+ "Epoch: 12 out of 30\n",
+ "Training Loss: 0.254\n",
+ "Test Loss: 0.377\n",
+ "Test Accuracy: 0.876\n",
+ "\n",
+ "Epoch: 13 out of 30\n",
+ "Training Loss: 0.244\n",
+ "Test Loss: 0.369\n",
+ "Test Accuracy: 0.879\n",
+ "\n",
+ "Epoch: 14 out of 30\n",
+ "Training Loss: 0.243\n",
+ "Test Loss: 0.371\n",
+ "Test Accuracy: 0.879\n",
+ "\n",
+ "Epoch: 15 out of 30\n",
+ "Training Loss: 0.237\n",
+ "Test Loss: 0.377\n",
+ "Test Accuracy: 0.883\n",
+ "\n",
+ "Epoch: 16 out of 30\n",
+ "Training Loss: 0.230\n",
+ "Test Loss: 0.407\n",
+ "Test Accuracy: 0.874\n",
+ "\n",
+ "Epoch: 17 out of 30\n",
+ "Training Loss: 0.228\n",
+ "Test Loss: 0.370\n",
+ "Test Accuracy: 0.879\n",
+ "\n",
+ "Epoch: 18 out of 30\n",
+ "Training Loss: 0.221\n",
+ "Test Loss: 0.376\n",
+ "Test Accuracy: 0.878\n",
+ "\n",
+ "Epoch: 19 out of 30\n",
+ "Training Loss: 0.222\n",
+ "Test Loss: 0.376\n",
+ "Test Accuracy: 0.881\n",
+ "\n",
+ "Epoch: 20 out of 30\n",
+ "Training Loss: 0.217\n",
+ "Test Loss: 0.387\n",
+ "Test Accuracy: 0.880\n",
+ "\n",
+ "Epoch: 21 out of 30\n",
+ "Training Loss: 0.209\n",
+ "Test Loss: 0.401\n",
+ "Test Accuracy: 0.877\n",
+ "\n",
+ "Epoch: 22 out of 30\n",
+ "Training Loss: 0.210\n",
+ "Test Loss: 0.392\n",
+ "Test Accuracy: 0.883\n",
+ "\n",
+ "Epoch: 23 out of 30\n",
+ "Training Loss: 0.204\n",
+ "Test Loss: 0.411\n",
+ "Test Accuracy: 0.878\n",
+ "\n",
+ "Epoch: 24 out of 30\n",
+ "Training Loss: 0.202\n",
+ "Test Loss: 0.391\n",
+ "Test Accuracy: 0.882\n",
+ "\n",
+ "Epoch: 25 out of 30\n",
+ "Training Loss: 0.195\n",
+ "Test Loss: 0.392\n",
+ "Test Accuracy: 0.883\n",
+ "\n",
+ "Epoch: 26 out of 30\n",
+ "Training Loss: 0.195\n",
+ "Test Loss: 0.471\n",
+ "Test Accuracy: 0.878\n",
+ "\n",
+ "Epoch: 27 out of 30\n",
+ "Training Loss: 0.191\n",
+ "Test Loss: 0.431\n",
+ "Test Accuracy: 0.881\n",
+ "\n",
+ "Epoch: 28 out of 30\n",
+ "Training Loss: 0.195\n",
+ "Test Loss: 0.418\n",
+ "Test Accuracy: 0.882\n",
+ "\n",
+ "Epoch: 29 out of 30\n",
+ "Training Loss: 0.192\n",
+ "Test Loss: 0.390\n",
+ "Test Accuracy: 0.887\n",
+ "\n",
+ "Epoch: 30 out of 30\n",
+ "Training Loss: 0.185\n",
+ "Test Loss: 0.428\n",
+ "Test Accuracy: 0.875\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "import torch\n",
+ "from torchvision import datasets, transforms\n",
+ "from torch import nn, optim\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, 0.5),\n",
+ " (0.5, 0.5, 0.5))])\n",
+ "\n",
+ "# Download and load the training data\n",
+ "trainset = datasets.FashionMNIST(\n",
+ " '.pytorch/F_MNIST_data/', download=True, train=True, transform=transform)\n",
+ "\n",
+ "trainloader = torch.utils.data.DataLoader(\n",
+ " trainset, batch_size=64, shuffle=True)\n",
+ "\n",
+ "# Download and load the test data\n",
+ "testset = datasets.FashionMNIST(\n",
+ " '.pytorch/F_MNIST_data/', download=True, train=False,\n",
+ " transform=transform)\n",
+ "\n",
+ "testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)\n",
+ "\n",
+ "\n",
+ "class Classifier(nn.Module):\n",
+ " def __init__(self):\n",
+ " super().__init__()\n",
+ " self.fc1 = nn.Linear(784, 256)\n",
+ " self.fc2 = nn.Linear(256, 128)\n",
+ " self.fc3 = nn.Linear(128, 64)\n",
+ " self.fc4 = nn.Linear(64, 10)\n",
+ "\n",
+ " def forward(self, x):\n",
+ " # make sure input tensor is flattened\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\n",
+ "\n",
+ "\n",
+ "model = Classifier()\n",
+ "\n",
+ "images, labels = next(iter(testloader))\n",
+ "\n",
+ "# Get the class probabilities\n",
+ "ps = torch.exp(model(images))\n",
+ "\n",
+ "# Make sure the shape is appropriate, we should get 10 class probabilities for\n",
+ "# 64 examples\n",
+ "print(ps.shape)\n",
+ "\n",
+ "top_p, top_class = ps.topk(1, dim=1)\n",
+ "# Look at the most likely classes for the first 10 examples\n",
+ "print(top_class[:10, :])\n",
+ "\n",
+ "\n",
+ "equals = top_class == labels.view(*top_class.shape)\n",
+ "\n",
+ "\n",
+ "accuracy = torch.mean(equals.type(torch.FloatTensor))\n",
+ "print(f'Accuracy: {accuracy.item()*100}%')\n",
+ "\n",
+ "\n",
+ "# Model begins\n",
+ "\n",
+ "model = Classifier()\n",
+ "criterion = nn.NLLLoss()\n",
+ "optimizer = optim.Adam(model.parameters(), lr=0.003)\n",
+ "\n",
+ "epochs = 30\n",
+ "steps = 0\n",
+ "\n",
+ "trainLosses, testLosses = [], []\n",
+ "for e in range(epochs):\n",
+ " runningLoss = 0\n",
+ " for images, labels in trainloader:\n",
+ "\n",
+ " optimizer.zero_grad()\n",
+ "\n",
+ " log_ps = model(images)\n",
+ " loss = criterion(log_ps, labels)\n",
+ " loss.backward()\n",
+ " optimizer.step()\n",
+ "\n",
+ " runningLoss += loss.item()\n",
+ "\n",
+ " else:\n",
+ " testLoss = 0\n",
+ " accuracy = 0\n",
+ "\n",
+ " # Turn off gradients for validation step\n",
+ " with torch.no_grad():\n",
+ " for images, labels in testloader:\n",
+ " # Get the output\n",
+ " log_ps = model(images)\n",
+ " # Get the loss\n",
+ " testLoss += criterion(log_ps, labels)\n",
+ "\n",
+ " # Get the probabilities\n",
+ " ps = torch.exp(log_ps)\n",
+ " # Get the most likely class for each prediction\n",
+ " top_p, top_class = ps.topk(1, dim=1)\n",
+ " # Check if the predictions match the actual label\n",
+ " equals = top_class == labels.view(*top_class.shape)\n",
+ " # Update accuracy\n",
+ " accuracy += torch.mean(equals.type(torch.FloatTensor))\n",
+ "\n",
+ " # Update train loss\n",
+ " trainLosses.append(runningLoss / len(trainloader))\n",
+ " # Update test loss\n",
+ " testLosses.append(testLoss / len(testloader))\n",
+ "\n",
+ " # Print output\n",
+ " print(f'Epoch: {e+1} out of {epochs}')\n",
+ " print(f'Training Loss: {runningLoss/len(trainloader):.3f}')\n",
+ " print(f'Test Loss: {testLoss/len(testloader):.3f}')\n",
+ " print(f'Test Accuracy: {accuracy/len(testloader):.3f}')\n",
+ " print()\n"
+ ]
+ },
+ {
+ "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
+}
diff --git a/python/Deep Learning/Deep Learning with PyTorch/fc_model.py b/python/Deep Learning/Deep Learning with PyTorch/fc_model.py
new file mode 100644
index 0000000..9c259f7
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/fc_model.py
@@ -0,0 +1,104 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+
+class Network(nn.Module):
+ def __init__(self, input_size, output_size, hidden_layers, drop_p=0.5):
+ ''' Builds a feedforward network with arbitrary hidden layers.
+
+ Arguments
+ ---------
+ input_size: integer, size of the input layer
+ output_size: integer, size of the output layer
+ hidden_layers: list of integers, the sizes of the hidden layers
+
+ '''
+ super().__init__()
+ # Input to a hidden layer
+ self.hidden_layers = nn.ModuleList(
+ [nn.Linear(input_size, hidden_layers[0])])
+
+ # Add a variable number of more hidden layers
+ layer_sizes = zip(hidden_layers[:-1], hidden_layers[1:])
+ self.hidden_layers.extend([nn.Linear(h1, h2)
+ for h1, h2 in layer_sizes])
+
+ self.output = nn.Linear(hidden_layers[-1], output_size)
+
+ self.dropout = nn.Dropout(p=drop_p)
+
+ def forward(self, x):
+ ''' Forward pass through the network, returns the output logits '''
+
+ for each in self.hidden_layers:
+ x = F.relu(each(x))
+ x = self.dropout(x)
+ x = self.output(x)
+
+ return F.log_softmax(x, dim=1)
+
+
+def validation(model, testloader, criterion):
+ accuracy = 0
+ test_loss = 0
+ for images, labels in testloader:
+
+ images = images.resize_(images.size()[0], 784)
+
+ output = model.forward(images)
+ test_loss += criterion(output, labels).item()
+
+ # Calculating the accuracy
+ # Model's output is log-softmax, take exponential to get the probabilities
+ ps = torch.exp(output)
+ # Class with highest probability is our predicted class, compare with true label
+ equality = (labels.data == ps.max(1)[1])
+ # Accuracy is number of correct predictions divided by all predictions, just take the mean
+ accuracy += equality.type_as(torch.FloatTensor()).mean()
+
+ return test_loss, accuracy
+
+
+def train(model, trainloader, testloader, criterion, optimizer, epochs=5, print_every=40):
+
+ steps = 0
+ running_loss = 0
+ for e in range(epochs):
+ # Model in training mode, dropout is on
+ model.train()
+ for images, labels in trainloader:
+ steps += 1
+
+ # Flatten images into a 784 long vector
+ images.resize_(images.size()[0], 784)
+
+ optimizer.zero_grad()
+
+ output = model.forward(images)
+ loss = criterion(output, labels)
+ loss.backward()
+ optimizer.step()
+
+ running_loss += loss.item()
+
+ if steps % print_every == 0:
+ # Model in inference mode, dropout is off
+ model.eval()
+
+ # Turn off gradients for validation, will speed up inference
+ with torch.no_grad():
+ test_loss, accuracy = validation(
+ model, testloader, criterion)
+
+ print("Epoch: {}/{}.. ".format(e + 1, epochs),
+ "Training Loss: {:.3f}.. ".format(
+ running_loss / print_every),
+ "Test Loss: {:.3f}.. ".format(
+ test_loss / len(testloader)),
+ "Test Accuracy: {:.3f}".format(accuracy / len(testloader)))
+
+ running_loss = 0
+
+ # Make sure dropout and grads are on for training
+ model.train()
diff --git a/python/Deep Learning/Deep Learning with PyTorch/helper.py b/python/Deep Learning/Deep Learning with PyTorch/helper.py
new file mode 100644
index 0000000..5152f1f
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/helper.py
@@ -0,0 +1,95 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from torch import nn, optim
+from torch.autograd import Variable
+
+
+def test_network(net, trainloader):
+
+ criterion = nn.MSELoss()
+ optimizer = optim.Adam(net.parameters(), lr=0.001)
+
+ dataiter = iter(trainloader)
+ images, labels = dataiter.next()
+
+ # Create Variables for the inputs and targets
+ inputs = Variable(images)
+ targets = Variable(images)
+
+ # Clear the gradients from all Variables
+ optimizer.zero_grad()
+
+ # Forward pass, then backward pass, then update weights
+ output = net.forward(inputs)
+ loss = criterion(output, targets)
+ loss.backward()
+ optimizer.step()
+
+ return True
+
+
+def imshow(image, ax=None, title=None, normalize=True):
+ """Imshow for Tensor."""
+ if ax is None:
+ fig, ax = plt.subplots()
+ image = image.numpy().transpose((1, 2, 0))
+
+ if normalize:
+ mean = np.array([0.485, 0.456, 0.406])
+ std = np.array([0.229, 0.224, 0.225])
+ image = std * image + mean
+ image = np.clip(image, 0, 1)
+
+ ax.imshow(image)
+ ax.spines['top'].set_visible(False)
+ ax.spines['right'].set_visible(False)
+ ax.spines['left'].set_visible(False)
+ ax.spines['bottom'].set_visible(False)
+ ax.tick_params(axis='both', length=0)
+ ax.set_xticklabels('')
+ ax.set_yticklabels('')
+
+ return ax
+
+
+def view_recon(img, recon):
+ ''' Function for displaying an image (as a PyTorch Tensor) and its
+ reconstruction also a PyTorch Tensor
+ '''
+
+ fig, axes = plt.subplots(ncols=2, sharex=True, sharey=True)
+ axes[0].imshow(img.numpy().squeeze())
+ axes[1].imshow(recon.data.numpy().squeeze())
+ for ax in axes:
+ ax.axis('off')
+ ax.set_adjustable('box-forced')
+
+
+def view_classify(img, ps, version="MNIST"):
+ ''' Function for viewing an image and it's predicted classes.
+ '''
+ ps = ps.data.numpy().squeeze()
+
+ fig, (ax1, ax2) = plt.subplots(figsize=(6, 9), ncols=2)
+ ax1.imshow(img.resize_(1, 28, 28).numpy().squeeze())
+ ax1.axis('off')
+ ax2.barh(np.arange(10), ps)
+ ax2.set_aspect(0.1)
+ ax2.set_yticks(np.arange(10))
+ if version == "MNIST":
+ ax2.set_yticklabels(np.arange(10))
+ elif version == "Fashion":
+ ax2.set_yticklabels(['T-shirt/top',
+ 'Trouser',
+ 'Pullover',
+ 'Dress',
+ 'Coat',
+ 'Sandal',
+ 'Shirt',
+ 'Sneaker',
+ 'Bag',
+ 'Ankle Boot'], size='small')
+ ax2.set_title('Class Probability')
+ ax2.set_xlim(0, 1.1)
+
+ plt.tight_layout()
diff --git a/python/Deep Learning/Deep Learning with PyTorch/python_scripts/fc_model.py b/python/Deep Learning/Deep Learning with PyTorch/python_scripts/fc_model.py
new file mode 100644
index 0000000..9c259f7
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/python_scripts/fc_model.py
@@ -0,0 +1,104 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+
+class Network(nn.Module):
+ def __init__(self, input_size, output_size, hidden_layers, drop_p=0.5):
+ ''' Builds a feedforward network with arbitrary hidden layers.
+
+ Arguments
+ ---------
+ input_size: integer, size of the input layer
+ output_size: integer, size of the output layer
+ hidden_layers: list of integers, the sizes of the hidden layers
+
+ '''
+ super().__init__()
+ # Input to a hidden layer
+ self.hidden_layers = nn.ModuleList(
+ [nn.Linear(input_size, hidden_layers[0])])
+
+ # Add a variable number of more hidden layers
+ layer_sizes = zip(hidden_layers[:-1], hidden_layers[1:])
+ self.hidden_layers.extend([nn.Linear(h1, h2)
+ for h1, h2 in layer_sizes])
+
+ self.output = nn.Linear(hidden_layers[-1], output_size)
+
+ self.dropout = nn.Dropout(p=drop_p)
+
+ def forward(self, x):
+ ''' Forward pass through the network, returns the output logits '''
+
+ for each in self.hidden_layers:
+ x = F.relu(each(x))
+ x = self.dropout(x)
+ x = self.output(x)
+
+ return F.log_softmax(x, dim=1)
+
+
+def validation(model, testloader, criterion):
+ accuracy = 0
+ test_loss = 0
+ for images, labels in testloader:
+
+ images = images.resize_(images.size()[0], 784)
+
+ output = model.forward(images)
+ test_loss += criterion(output, labels).item()
+
+ # Calculating the accuracy
+ # Model's output is log-softmax, take exponential to get the probabilities
+ ps = torch.exp(output)
+ # Class with highest probability is our predicted class, compare with true label
+ equality = (labels.data == ps.max(1)[1])
+ # Accuracy is number of correct predictions divided by all predictions, just take the mean
+ accuracy += equality.type_as(torch.FloatTensor()).mean()
+
+ return test_loss, accuracy
+
+
+def train(model, trainloader, testloader, criterion, optimizer, epochs=5, print_every=40):
+
+ steps = 0
+ running_loss = 0
+ for e in range(epochs):
+ # Model in training mode, dropout is on
+ model.train()
+ for images, labels in trainloader:
+ steps += 1
+
+ # Flatten images into a 784 long vector
+ images.resize_(images.size()[0], 784)
+
+ optimizer.zero_grad()
+
+ output = model.forward(images)
+ loss = criterion(output, labels)
+ loss.backward()
+ optimizer.step()
+
+ running_loss += loss.item()
+
+ if steps % print_every == 0:
+ # Model in inference mode, dropout is off
+ model.eval()
+
+ # Turn off gradients for validation, will speed up inference
+ with torch.no_grad():
+ test_loss, accuracy = validation(
+ model, testloader, criterion)
+
+ print("Epoch: {}/{}.. ".format(e + 1, epochs),
+ "Training Loss: {:.3f}.. ".format(
+ running_loss / print_every),
+ "Test Loss: {:.3f}.. ".format(
+ test_loss / len(testloader)),
+ "Test Accuracy: {:.3f}".format(accuracy / len(testloader)))
+
+ running_loss = 0
+
+ # Make sure dropout and grads are on for training
+ model.train()
diff --git a/python/Deep Learning/Deep Learning with PyTorch/python_scripts/part5_inference_and_validation.py b/python/Deep Learning/Deep Learning with PyTorch/python_scripts/part5_inference_and_validation.py
new file mode 100644
index 0000000..0a66a06
--- /dev/null
+++ b/python/Deep Learning/Deep Learning with PyTorch/python_scripts/part5_inference_and_validation.py
@@ -0,0 +1,130 @@
+import torch
+from torchvision import datasets, transforms
+from torch import nn, optim
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+
+# Define a transform to normalize the data
+transform = transforms.Compose([transforms.ToTensor(),
+ transforms.Normalize((0.5, 0.5, 0.5),
+ (0.5, 0.5, 0.5))])
+
+# Download and load the training data
+trainset = datasets.FashionMNIST(
+ '.pytorch/F_MNIST_data/', download=True, train=True, transform=transform)
+
+trainloader = torch.utils.data.DataLoader(
+ trainset, batch_size=64, shuffle=True)
+
+# Download and load the test data
+testset = datasets.FashionMNIST(
+ '.pytorch/F_MNIST_data/', download=True, train=False,
+ transform=transform)
+
+testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=True)
+
+
+class Classifier(nn.Module):
+ def __init__(self):
+ super().__init__()
+ self.fc1 = nn.Linear(784, 256)
+ self.fc2 = nn.Linear(256, 128)
+ self.fc3 = nn.Linear(128, 64)
+ self.fc4 = nn.Linear(64, 10)
+
+ def forward(self, x):
+ # make sure input tensor is flattened
+ x = x.view(x.shape[0], -1)
+
+ x = F.relu(self.fc1(x))
+ x = F.relu(self.fc2(x))
+ x = F.relu(self.fc3(x))
+ x = F.log_softmax(self.fc4(x), dim=1)
+
+ return x
+
+
+model = Classifier()
+
+images, labels = next(iter(testloader))
+
+# Get the class probabilities
+ps = torch.exp(model(images))
+
+# Make sure the shape is appropriate, we should get 10 class probabilities for
+# 64 examples
+print(ps.shape)
+
+top_p, top_class = ps.topk(1, dim=1)
+# Look at the most likely classes for the first 10 examples
+print(top_class[:10, :])
+
+
+equals = top_class == labels.view(*top_class.shape)
+
+
+accuracy = torch.mean(equals.type(torch.FloatTensor))
+print(f'Accuracy: {accuracy.item()*100}%')
+
+
+# Model begins
+
+model = Classifier()
+criterion = nn.NLLLoss()
+optimizer = optim.Adam(model.parameters(), lr=0.003)
+
+epochs = 30
+steps = 0
+
+trainLosses, testLosses = [], []
+for e in range(epochs):
+ runningLoss = 0
+ for images, labels in trainloader:
+
+ optimizer.zero_grad()
+
+ log_ps = model(images)
+ loss = criterion(log_ps, labels)
+ loss.backward()
+ optimizer.step()
+
+ runningLoss += loss.item()
+
+ else:
+ testLoss = 0
+ accuracy = 0
+
+ # Turn off gradients for validation step
+ with torch.no_grad():
+ for images, labels in testloader:
+ # Get the output
+ log_ps = model(images)
+ # Get the loss
+ testLoss += criterion(log_ps, labels)
+
+ # Get the probabilities
+ ps = torch.exp(log_ps)
+ # Get the most likely class for each prediction
+ top_p, top_class = ps.topk(1, dim=1)
+ # Check if the predictions match the actual label
+ equals = top_class == labels.view(*top_class.shape)
+ # Update accuracy
+ accuracy += torch.mean(equals.type(torch.FloatTensor))
+
+ # Update train loss
+ trainLosses.append(runningLoss / len(trainloader))
+ # Update test loss
+ testLosses.append(testLoss / len(testloader))
+
+ # Print output
+ print(f'Epoch: {e+1} out of {epochs}')
+ print(f'Training Loss: {runningLoss/len(trainloader):.3f}')
+ print(f'Test Loss: {testLoss/len(testloader):.3f}')
+ print(f'Test Accuracy: {accuracy/len(testloader):.3f}')
+ print()
+
+
+plt.plot(trainLosses, label='Training loss')
+plt.plot(testLosses, label='Validation loss')
+plt.legend(frameon=False)
+plt.show()