This post is the second in a series of tutorials on building deep learning models with PyTorch, an open source neural networks library developed and maintained by Facebook. Check out the full series:
Continuing where the previous tutorial left off, we'll discuss one of the foundational algorithms of machine learning in this post: Linear regression. We'll create a model that predicts crop yields for apples and oranges (target variables) by looking at the average temperature, rainfall and humidity (input variables or features) in a region. Here's the training data:
In a linear regression model, each target variable is estimated to be a weighted sum of the input variables, offset by some constant, known as a bias :
yield_apple = w11 * temp + w12 * rainfall + w13 * humidity + b1
yield_orange = w21 * temp + w22 * rainfall + w23 * humidity + b2
Visually, it means that the yield of apples is a linear or planar function of temperature, rainfall and humidity:
The learning part of linear regression is to figure out a set of weights w11, w12,... w23, b1 & b2
by looking at the training data, to make accurate predictions for new data (i.e. to predict the yields for apples and oranges in a new region using the average temperature, rainfall and humidity). This is done by adjusting the weights slightly many times to make better predictions, using an optimization technique called gradient descent.
If you want to follow along and run the code as you read, you can clone this notebook, install the required dependencies, and start Jupyter by running the following commands on the terminal:
pip install jovian --upgrade # Install the jovian library
jovian clone <notebook_id> # Download notebook & dependencies
cd 02-linear-regression # Enter the created directory
jovian install # Install the dependencies
conda activate 02-linear-regression # Activate virtual environment
jupyter notebook # Start Jupyter
You can find the notebook_id
by cliking the Clone button at the top of this page on Jovian. On older versions of conda, you might need to run source activate 02-linear-regression
to activate the environment. For a more detailed explanation of the above steps, check out the System setup section in the previous notebook.
We begin by importing Numpy and PyTorch:
import numpy as np
import torch
The training data can be represented using 2 matrices: inputs
and targets
, each with one row per observation, and one column per variable.
# Input (temp, rainfall, humidity)
inputs = np.array([[73, 67, 43],
[91, 88, 64],
[87, 134, 58],
[102, 43, 37],
[69, 96, 70]], dtype='float32')
# Targets (apples, oranges)
targets = np.array([[56, 70],
[81, 101],
[119, 133],
[22, 37],
[103, 119]], dtype='float32')
We've separated the input and target variables, because we'll operate on them separately. Also, we've created numpy arrays, because this is typically how you would work with training data: read some CSV files as numpy arrays, do some processing, and then convert them to PyTorch tensors as follows:
# Convert inputs and targets to tensors
inputs = torch.from_numpy(inputs)
targets = torch.from_numpy(targets)
print(inputs)
print(targets)
tensor([[ 73., 67., 43.],
[ 91., 88., 64.],
[ 87., 134., 58.],
[102., 43., 37.],
[ 69., 96., 70.]])
tensor([[ 56., 70.],
[ 81., 101.],
[119., 133.],
[ 22., 37.],
[103., 119.]])
The weights and biases (w11, w12,... w23, b1 & b2
) can also be represented as matrices, initialized as random values. The first row of w
and the first element of b
are used to predict the first target variable i.e. yield of apples, and similarly the second for oranges.
# Weights and biases
w = torch.randn(2, 3, requires_grad=True)
b = torch.randn(2, requires_grad=True)
print(w)
print(b)
tensor([[ 1.7705, 0.8743, -0.9821],
[ 0.3809, 0.5635, -1.5331]], requires_grad=True)
tensor([ 0.2508, -0.5731], requires_grad=True)
torch.randn
creates a tensor with the given shape, with elements picked randomly from a normal distribution with mean 0 and standard deviation 1.
Our model is simply a function that performs a matrix multiplication of the inputs
and the weights w
(transposed) and adds the bias b
(replicated for each observation).
We can define the model as follows:
def model(x):
return x @ w.t() + b
@
represents matrix multiplication in PyTorch, and the .t
method returns the transpose of a tensor.
The matrix obtained by passing the input data into the model is a set of predictions for the target variables.
# Generate predictions
preds = model(inputs)
print(preds)
tensor([[145.8405, -0.9364],
[175.4443, -14.4415],
[214.4718, 19.1564],
[182.0942, 5.7820],
[137.5954, -27.5105]], grad_fn=<AddBackward0>)
Let's compare the predictions of our model with the actual targets.
# Compare with targets
print(targets)
tensor([[ 56., 70.],
[ 81., 101.],
[119., 133.],
[ 22., 37.],
[103., 119.]])
You can see that there's a huge difference between the predictions of our model, and the actual values of the target variables. Obviously, this is because we've initialized our model with random weights and biases, and we can't expect it to just work.
Before we improve our model, we need a way to evaluate how well our model is performing. We can compare the model's predictions with the actual targets, using the following method:
preds
and targets
).The result is a single number, known as the mean squared error (MSE).
# MSE loss
def mse(t1, t2):
diff = t1 - t2
return torch.sum(diff * diff) / diff.numel()
torch.sum
returns the sum of all the elements in a tensor, and the .numel
method returns the number of elements in a tensor. Let's compute the mean squared error for the current predictions of our model.
# Compute loss
loss = mse(preds, targets)
print(loss)
tensor(10669.1904, grad_fn=<DivBackward0>)
Here’s how we can interpret the result: On average, each element in the prediction differs from the actual target by about 138 (square root of the loss 19044). And that’s pretty bad, considering the numbers we are trying to predict are themselves in the range 50–200. Also, the result is called the loss, because it indicates how bad the model is at predicting the target variables. Lower the loss, better the model.
With PyTorch, we can automatically compute the gradient or derivative of the loss w.r.t. to the weights and biases, because they have requires_grad
set to True
.
# Compute gradients
loss.backward()
---------------------------------------------------------------------------
RuntimeError Traceback (most recent call last)
<ipython-input-16-e6912923c183> in <module>
1 # Compute gradients
----> 2 loss.backward()
/srv/conda/envs/notebook/lib/python3.7/site-packages/torch/tensor.py in backward(self, gradient, retain_graph, create_graph)
100 products. Defaults to ``False``.
101 """
--> 102 torch.autograd.backward(self, gradient, retain_graph, create_graph)
103
104 def register_hook(self, hook):
/srv/conda/envs/notebook/lib/python3.7/site-packages/torch/autograd/__init__.py in backward(tensors, grad_tensors, retain_graph, create_graph, grad_variables)
88 Variable._execution_engine.run_backward(
89 tensors, grad_tensors, retain_graph, create_graph,
---> 90 allow_unreachable=True) # allow_unreachable flag
91
92
RuntimeError: Trying to backward through the graph a second time, but the buffers have already been freed. Specify retain_graph=True when calling backward the first time.
The gradients are stored in the .grad
property of the respective tensors. Note that the derivative of the loss w.r.t. the weights matrix is itself a matrix, with the same dimensions.
# Gradients for weights
print(w)
print(w.grad)
tensor([[ 1.7705, 0.8743, -0.9821],
[ 0.3809, 0.5635, -1.5331]], requires_grad=True)
tensor([[ 8435.1064, 7465.7705, 4758.0220],
[-7776.2773, -9114.8047, -5690.4512]])
The loss is a quadratic function of our weights and biases, and our objective is to find the set of weights where the loss is the lowest. If we plot a graph of the loss w.r.t any individual weight or bias element, it will look like the figure shown below. A key insight from calculus is that the gradient indicates the rate of change of the loss, or the slope of the loss function w.r.t. the weights and biases.
If a gradient element is positive:
If a gradient element is negative:
The increase or decrease in loss by changing a weight element is proportional to the value of the gradient of the loss w.r.t. that element. This forms the basis for the optimization algorithm that we'll use to improve our model.
Before we proceed, we reset the gradients to zero by calling .zero_()
method. We need to do this, because PyTorch accumulates, gradients i.e. the next time we call .backward
on the loss, the new gradient values will get added to the existing gradient values, which may lead to unexpected results.
w.grad.zero_()
b.grad.zero_()
print(w.grad)
print(b.grad)
tensor([[0., 0., 0.],
[0., 0., 0.]])
tensor([0., 0.])
We'll reduce the loss and improve our model using the gradient descent optimization algorithm, which has the following steps:
Generate predictions
Calculate the loss
Compute gradients w.r.t the weights and biases
Adjust the weights by subtracting a small quantity proportional to the gradient
Reset the gradients to zero
Let's implement the above step by step.
# Generate predictions
preds = model(inputs)
print(preds)
tensor([[-1174.8188, 1422.2087],
[-1553.7466, 1859.5872],
[-1795.8561, 2247.2183],
[-1175.4565, 1401.5414],
[-1494.2974, 1782.5011]], grad_fn=<AddBackward0>)
Note that the predictions are same as before, since we haven't made any changes to our model. The same holds true for the loss and gradients.
# Calculate the loss
loss = mse(preds, targets)
print(loss)
tensor(2585947.2500, grad_fn=<DivBackward0>)
# Compute gradients
loss.backward()
print(w.grad)
print(b.grad)
tensor([[-127511.6562, -137548.8906, -84945.4688],
[ 139328.8906, 149406.0625, 92050.4688]])
tensor([-1515.0352, 1650.6113])
Finally, we update the weights and biases using the gradients computed above.
dir(loss)
['__abs__',
'__add__',
'__and__',
'__array__',
'__array_priority__',
'__array_wrap__',
'__bool__',
'__class__',
'__deepcopy__',
'__delattr__',
'__delitem__',
'__dict__',
'__dir__',
'__div__',
'__doc__',
'__eq__',
'__float__',
'__floordiv__',
'__format__',
'__ge__',
'__getattribute__',
'__getitem__',
'__gt__',
'__hash__',
'__iadd__',
'__iand__',
'__idiv__',
'__ilshift__',
'__imul__',
'__index__',
'__init__',
'__init_subclass__',
'__int__',
'__invert__',
'__ior__',
'__ipow__',
'__irshift__',
'__isub__',
'__iter__',
'__itruediv__',
'__ixor__',
'__le__',
'__len__',
'__long__',
'__lshift__',
'__lt__',
'__matmul__',
'__mod__',
'__module__',
'__mul__',
'__ne__',
'__neg__',
'__new__',
'__nonzero__',
'__or__',
'__pow__',
'__radd__',
'__rdiv__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__reversed__',
'__rfloordiv__',
'__rmul__',
'__rpow__',
'__rshift__',
'__rsub__',
'__rtruediv__',
'__setattr__',
'__setitem__',
'__setstate__',
'__sizeof__',
'__str__',
'__sub__',
'__subclasshook__',
'__truediv__',
'__weakref__',
'__xor__',
'_backward_hooks',
'_base',
'_cdata',
'_coalesced_',
'_dimI',
'_dimV',
'_grad',
'_grad_fn',
'_indices',
'_make_subclass',
'_nnz',
'_values',
'_version',
'abs',
'abs_',
'acos',
'acos_',
'add',
'add_',
'addbmm',
'addbmm_',
'addcdiv',
'addcdiv_',
'addcmul',
'addcmul_',
'addmm',
'addmm_',
'addmv',
'addmv_',
'addr',
'addr_',
'all',
'allclose',
'any',
'apply_',
'argmax',
'argmin',
'argsort',
'as_strided',
'as_strided_',
'asin',
'asin_',
'atan',
'atan2',
'atan2_',
'atan_',
'backward',
'baddbmm',
'baddbmm_',
'bernoulli',
'bernoulli_',
'bincount',
'bmm',
'btrifact',
'btrifact_with_info',
'btrisolve',
'byte',
'cauchy_',
'ceil',
'ceil_',
'char',
'cholesky',
'chunk',
'clamp',
'clamp_',
'clamp_max',
'clamp_max_',
'clamp_min',
'clamp_min_',
'clone',
'coalesce',
'contiguous',
'copy_',
'cos',
'cos_',
'cosh',
'cosh_',
'cpu',
'cross',
'cuda',
'cumprod',
'cumsum',
'data',
'data_ptr',
'dense_dim',
'det',
'detach',
'detach_',
'device',
'diag',
'diag_embed',
'diagflat',
'diagonal',
'digamma',
'digamma_',
'dim',
'dist',
'div',
'div_',
'dot',
'double',
'dtype',
'eig',
'element_size',
'eq',
'eq_',
'equal',
'erf',
'erf_',
'erfc',
'erfc_',
'erfinv',
'erfinv_',
'exp',
'exp_',
'expand',
'expand_as',
'expm1',
'expm1_',
'exponential_',
'fft',
'fill_',
'flatten',
'flip',
'float',
'floor',
'floor_',
'fmod',
'fmod_',
'frac',
'frac_',
'gather',
'ge',
'ge_',
'gels',
'geometric_',
'geqrf',
'ger',
'gesv',
'get_device',
'grad',
'grad_fn',
'gt',
'gt_',
'half',
'hardshrink',
'histc',
'ifft',
'index_add',
'index_add_',
'index_copy',
'index_copy_',
'index_fill',
'index_fill_',
'index_put',
'index_put_',
'index_select',
'indices',
'int',
'inverse',
'irfft',
'is_coalesced',
'is_complex',
'is_contiguous',
'is_cuda',
'is_distributed',
'is_floating_point',
'is_leaf',
'is_nonzero',
'is_pinned',
'is_same_size',
'is_set_to',
'is_shared',
'is_signed',
'is_sparse',
'isclose',
'item',
'kthvalue',
'layout',
'le',
'le_',
'lerp',
'lerp_',
'lgamma',
'lgamma_',
'log',
'log10',
'log10_',
'log1p',
'log1p_',
'log2',
'log2_',
'log_',
'log_normal_',
'log_softmax',
'logdet',
'logsumexp',
'long',
'lt',
'lt_',
'map2_',
'map_',
'masked_fill',
'masked_fill_',
'masked_scatter',
'masked_scatter_',
'masked_select',
'matmul',
'matrix_power',
'max',
'mean',
'median',
'min',
'mm',
'mode',
'mul',
'mul_',
'multinomial',
'mv',
'mvlgamma',
'mvlgamma_',
'name',
'narrow',
'narrow_copy',
'ndimension',
'ne',
'ne_',
'neg',
'neg_',
'nelement',
'new',
'new_empty',
'new_full',
'new_ones',
'new_tensor',
'new_zeros',
'nonzero',
'norm',
'normal_',
'numel',
'numpy',
'orgqr',
'ormqr',
'output_nr',
'permute',
'pin_memory',
'pinverse',
'polygamma',
'polygamma_',
'potrf',
'potri',
'potrs',
'pow',
'pow_',
'prelu',
'prod',
'pstrf',
'put_',
'qr',
'random_',
'reciprocal',
'reciprocal_',
'record_stream',
'register_hook',
'reinforce',
'relu',
'relu_',
'remainder',
'remainder_',
'renorm',
'renorm_',
'repeat',
'requires_grad',
'requires_grad_',
'reshape',
'reshape_as',
'resize',
'resize_',
'resize_as',
'resize_as_',
'retain_grad',
'rfft',
'roll',
'rot90',
'round',
'round_',
'rsqrt',
'rsqrt_',
'scatter',
'scatter_',
'scatter_add',
'scatter_add_',
'select',
'set_',
'shape',
'share_memory_',
'short',
'sigmoid',
'sigmoid_',
'sign',
'sign_',
'sin',
'sin_',
'sinh',
'sinh_',
'size',
'slogdet',
'smm',
'softmax',
'sort',
'sparse_dim',
'sparse_mask',
'sparse_resize_',
'sparse_resize_and_clear_',
'split',
'split_with_sizes',
'sqrt',
'sqrt_',
'squeeze',
'squeeze_',
'sspaddmm',
'std',
'stft',
'storage',
'storage_offset',
'storage_type',
'stride',
'sub',
'sub_',
'sum',
'svd',
'symeig',
't',
't_',
'take',
'tan',
'tan_',
'tanh',
'tanh_',
'to',
'to_dense',
'to_sparse',
'tolist',
'topk',
'trace',
'transpose',
'transpose_',
'tril',
'tril_',
'triu',
'triu_',
'trtrs',
'trunc',
'trunc_',
'type',
'type_as',
'unbind',
'unfold',
'uniform_',
'unique',
'unsqueeze',
'unsqueeze_',
'values',
'var',
'view',
'view_as',
'where',
'zero_']
# Adjust weights & reset gradients
with torch.no_grad():
w -= w.grad * 1e-5
b -= b.grad * 1e-5
w.grad.zero_()
b.grad.zero_()
A few things to note above:
We use torch.no_grad
to indicate to PyTorch that we shouldn't track, calculate or modify gradients while updating the weights and biases.
We multiply the gradients with a really small number (10^-5
in this case), to ensure that we don't modify the weights by a really large amount, since we only want to take a small step in the downhill direction of the gradient. This number is called the learning rate of the algorithm.
After we have updated the weights, we reset the gradients back to zero, to avoid affecting any future computations.
w
tensor([[ 120.8470, 130.9574, 79.2053],
[-131.1718, -139.7277, -87.8931]], requires_grad=True)
Let's take a look at the new weights and biases.
print(w)
print(b)
tensor([[ 120.8470, 130.9574, 79.2053],
[-131.1718, -139.7277, -87.8931]], requires_grad=True)
tensor([ 1.6709, -2.1281], requires_grad=True)
With the new weights and biases, the model should have lower loss.
# Calculate loss
preds = model(inputs)
loss = mse(preds, targets)
print(loss)
tensor(7.3925e+08, grad_fn=<DivBackward0>)
We have already achieved a significant reduction in the loss, simply by adjusting the weights and biases slightly using gradient descent.
To reduce the loss further, we can repeat the process of adjusting the weights and biases using the gradients multiple times. Each iteration is called an epoch. Let's train the model for 100 epochs.
# Train for 100 epochs
for i in range(100):
preds = model(inputs)
loss = mse(preds, targets)
loss.backward()
with torch.no_grad():
w -= w.grad * 1e-5
b -= b.grad * 1e-5
w.grad.zero_()
b.grad.zero_()
Once again, let's verify that the loss is now lower:
# Calculate loss
preds = model(inputs)
loss = mse(preds, targets)
print(loss)
tensor(247.7906, grad_fn=<DivBackward0>)
As you can see, the loss is now much lower than what we started out with. Let's look at the model's predictions and compare them with the targets.
# Predictions
preds
tensor([[ 59.4006, 72.0829],
[ 72.7364, 89.4102],
[136.6393, 155.7134],
[ 32.7355, 46.6240],
[ 78.6911, 93.8295]], grad_fn=<AddBackward0>)
# Targets
targets
tensor([[ 56., 70.],
[ 81., 101.],
[119., 133.],
[ 22., 37.],
[103., 119.]])
The prediction are now quite close to the target variables, and we can get even better results by training for a few more epochs.
The model and training process above were implemented using basic matrix operations. But since this such a common pattern , PyTorch has several built-in functions and classes to make it easy to create and train models.
Let's begin by importing the torch.nn
package from PyTorch, which contains utility classes for building neural networks.
import torch.nn as nn
As before, we represent the inputs and targets and matrices.
# Input (temp, rainfall, humidity)
inputs = np.array([[73, 67, 43], [91, 88, 64], [87, 134, 58],
[102, 43, 37], [69, 96, 70], [73, 67, 43],
[91, 88, 64], [87, 134, 58], [102, 43, 37],
[69, 96, 70], [73, 67, 43], [91, 88, 64],
[87, 134, 58], [102, 43, 37], [69, 96, 70]],
dtype='float32')
# Targets (apples, oranges)
targets = np.array([[56, 70], [81, 101], [119, 133],
[22, 37], [103, 119], [56, 70],
[81, 101], [119, 133], [22, 37],
[103, 119], [56, 70], [81, 101],
[119, 133], [22, 37], [103, 119]],
dtype='float32')
inputs = torch.from_numpy(inputs)
targets = torch.from_numpy(targets)
We are using 15 training examples this time, to illustrate how to work with large datasets in small batches.
We'll create a TensorDataset
, which allows access to rows from inputs
and targets
as tuples, and provides standard APIs for working with many different types of datasets in PyTorch.
from torch.utils.data import TensorDataset
# Define dataset
train_ds = TensorDataset(inputs, targets)
train_ds[0:3]
(tensor([[ 73., 67., 43.],
[ 91., 88., 64.],
[ 87., 134., 58.]]), tensor([[ 56., 70.],
[ 81., 101.],
[119., 133.]]))
The TensorDataset
allows us to access a small section of the training data using the array indexing notation ([0:3]
in the above code). It returns a tuple (or pair), in which the first element contains the input variables for the selected rows, and the second contains the targets.
We'll also create a DataLoader
, which can split the data into batches of a predefined size while training. It also provides other utilities like shuffling and random sampling of the data.
from torch.utils.data import DataLoader
# Define data loader
batch_size = 5
train_dl = DataLoader(train_ds, batch_size, shuffle=True)
The data loader is typically used in a for-in
loop. Let's look at an example.
for xb, yb in train_dl:
print(xb)
print(yb)
break
tensor([[ 91., 88., 64.],
[ 91., 88., 64.],
[ 73., 67., 43.],
[ 91., 88., 64.],
[ 87., 134., 58.]])
tensor([[ 81., 101.],
[ 81., 101.],
[ 56., 70.],
[ 81., 101.],
[119., 133.]])
In each iteration, the data loader returns one batch of data, with the given batch size. If shuffle
is set to True
, it shuffles the training data before creating batches. Shuffling helps randomize the input to the optimization algorithm, which can lead to faster reduction in the loss.
Instead of initializing the weights & biases manually, we can define the model using the nn.Linear
class from PyTorch, which does it automatically.
# Define model
model = nn.Linear(3, 2)
print(model.weight)
print(model.bias)
Parameter containing:
tensor([[0.2370, 0.2762, 0.3294],
[0.3333, 0.0848, 0.2115]], requires_grad=True)
Parameter containing:
tensor([-0.3043, -0.0734], requires_grad=True)
PyTorch models also have a helpful .parameters
method, which returns a list containing all the weights and bias matrices present in the model. For our linear regression model, we have one weight matrix and one bias matrix.
# Parameters
list(model.parameters())
[Parameter containing:
tensor([[0.2370, 0.2762, 0.3294],
[0.3333, 0.0848, 0.2115]], requires_grad=True), Parameter containing:
tensor([-0.3043, -0.0734], requires_grad=True)]
We can use the model to generate predictions in the exact same way as before:
targets
tensor([[ 56., 70.],
[ 81., 101.],
[119., 133.],
[ 22., 37.],
[103., 119.],
[ 56., 70.],
[ 81., 101.],
[119., 133.],
[ 22., 37.],
[103., 119.],
[ 56., 70.],
[ 81., 101.],
[119., 133.],
[ 22., 37.],
[103., 119.]])
# Generate predictions
preds = model(inputs)
preds
tensor([[49.6643, 39.0380],
[66.6470, 51.2608],
[76.4258, 52.5598],
[47.9342, 45.4005],
[65.6178, 45.8747],
[49.6643, 39.0380],
[66.6470, 51.2608],
[76.4258, 52.5598],
[47.9342, 45.4005],
[65.6178, 45.8747],
[49.6643, 39.0380],
[66.6470, 51.2608],
[76.4258, 52.5598],
[47.9342, 45.4005],
[65.6178, 45.8747]], grad_fn=<AddmmBackward>)
Instead of defining a loss function manually, we can use the built-in loss function mse_loss
.
# Import nn.functional
import torch.nn.functional as F
The nn.functional
package contains many useful loss functions and several other utilities.
# Define loss function
loss_fn = F.mse_loss
Let's compute the loss for the current predictions of our model.
loss = loss_fn(model(inputs), targets)
print(loss)
tensor(1944.9862, grad_fn=<MseLossBackward>)
Instead of manually manipulating the model's weights & biases using gradients, we can use the optimizer optim.SGD
. SGD stands for stochastic gradient descent
. It is called stochastic
because samples are selected in batches (often with random shuffling) instead of as a single group.
# Define optimizer
opt = torch.optim.SGD(model.parameters(), lr=1e-5)
Note that model.parameters()
is passed as an argument to optim.SGD
, so that the optimizer knows which matrices should be modified during the update step. Also, we can specify a learning rate which controls the amount by which the parameters are modified.
We are now ready to train the model. We'll follow the exact same process to implement gradient descent:
Generate predictions
Calculate the loss
Compute gradients w.r.t the weights and biases
Adjust the weights by subtracting a small quantity proportional to the gradient
Reset the gradients to zero
The only change is that we'll work batches of data, instead of processing the entire training data in every iteration. Let's define a utility function fit
which trains the model for a given number of epochs.
# Utility function to train the model
def fit(num_epochs, model, loss_fn, opt):
# Repeat for given number of epochs
for epoch in range(num_epochs):
# Train with batches of data
for xb,yb in train_dl:
# 1. Generate predictions
pred = model(xb)
# 2. Calculate loss
loss = loss_fn(pred, yb)
# 3. Compute gradients
loss.backward()
# 4. Update parameters using gradients
opt.step()
# 5. Reset the gradients to zero
opt.zero_grad()
# Print the progress
if (epoch+1) % 10 == 0:
print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))
Some things to note above:
We use the data loader defined earlier to get batches of data for every iteration.
Instead of updating parameters (weights and biases) manually, we use opt.step
to perform the update, and opt.zero_grad
to reset the gradients to zero.
We've also added a log statement which prints the loss from the last batch of data for every 10th epoch, to track the progress of training. loss.item
returns the actual value stored in the loss tensor.
Let's train the model for 100 epochs.
fit(100, model, loss_fn, opt)
Epoch [10/100], Loss: 376.6247
Epoch [20/100], Loss: 277.7932
Epoch [30/100], Loss: 92.0723
Epoch [40/100], Loss: 104.4702
Epoch [50/100], Loss: 75.5420
Epoch [60/100], Loss: 11.7809
Epoch [70/100], Loss: 24.6205
Epoch [80/100], Loss: 70.9926
Epoch [90/100], Loss: 18.7383
Epoch [100/100], Loss: 31.3071
Let's generate predictions using our model and verify that they're close to our targets.
# Generate predictions
preds = model(inputs)
preds
tensor([[ 58.3014, 71.7694],
[ 81.7077, 98.9111],
[118.1304, 134.6820],
[ 27.7541, 45.2431],
[ 97.0881, 111.2563],
[ 58.3014, 71.7694],
[ 81.7077, 98.9111],
[118.1304, 134.6820],
[ 27.7541, 45.2431],
[ 97.0881, 111.2563],
[ 58.3014, 71.7694],
[ 81.7077, 98.9111],
[118.1304, 134.6820],
[ 27.7541, 45.2431],
[ 97.0881, 111.2563]], grad_fn=<AddmmBackward>)
# Compare with targets
targets
tensor([[ 56., 70.],
[ 81., 101.],
[119., 133.],
[ 22., 37.],
[103., 119.],
[ 56., 70.],
[ 81., 101.],
[119., 133.],
[ 22., 37.],
[103., 119.],
[ 56., 70.],
[ 81., 101.],
[119., 133.],
[ 22., 37.],
[103., 119.]])
Indeed, the predictions are quite close to our targets, and now we have a fairly good model to predict crop yields for apples and oranges by looking at the average temperature, rainfall and humidity in a region.
As a final step, we can save and commit our work using the jovian library.
pip install jovian --upgrade -q
Note: you may need to restart the kernel to use updated packages.
import jovian
jovian.commit()
[jovian] Saving notebook..
Jovian uploads the notebook to https://jvn.io, captures the Python environment and creates a sharable link for the notebook. You can use this link to share your work and let anyone reproduce it easily with the jovian clone command. Jovian also includes a powerful commenting interface, so you (and others) can discuss & comment on specific parts of your notebook:
We've covered a lot of ground this this tutorial, including linear regression and the gradient descent optimization algorithm. Here are a few resources if you'd like to dig deeper into these topics:
For a more detailed explanation of derivates and gradient descent, see these notes from a Udacity course.
For an animated visualization of how linear regression works, see this post.
For a more mathematical treatment of matrix calculus, linear regression and gradient descent, you should check out Andrew Ng's excellent course notes from CS229 at Stanford University.
To practice and test your skills, you can participate in the Boston Housing Price Prediction competition on Kaggle, a website that hosts data science competitions.
With this, we complete our discussion of linear regression in PyTorch, and we’re ready to move on to the next topic: Logistic regression.