Reshaping Tensors

view() takes list of number and reshapes the tensor as per the arguments.

The constrain is for view(a, b, c,....n) a x b x c x ... x n should be equal to the size of the given tensor. If you give '-1' as the last argument to view() it will calculate the last dimension by itself.

x = x.view(2, 5)
print(x)

  1  2  3  4  5
  6  7  8  9  10
[torch.FloatTensor of size 2x5]

# making matrices by hand is hard right?
x  = torch.range(1, 16)
x_ = x.view(2, 8)
print(x_)

    1     2     3     4     5     6     7     8
    9    10    11    12    13    14    15    16
[torch.FloatTensor of size 2x8]


x_ = x.view(2, 2, 4)
print(x_)

(0 ,.,.) =
   1   2   3   4
   5   6   7   8

(1 ,.,.) =
   9  10  11  12
  13  14  15  16
[torch.FloatTensor of size 2x2x4]


x_ = x.view(2, 2, 2, -1)
print(x_)

(0 ,0 ,.,.) =
   1   2
   3   4

(0 ,1 ,.,.) =
   5   6
   7   8

(1 ,0 ,.,.) =
   9  10
  11  12

(1 ,1 ,.,.) =
  13  14
  15  16
[torch.FloatTensor of size 2x2x2x2]


x[5] = -1 * x[5]
print(x_)

(0 ,0 ,.,.) =
   1   2
   3   4

(0 ,1 ,.,.) =
   5  -6
   7   8

(1 ,0 ,.,.) =
   9  10
  11  12

(1 ,1 ,.,.) =
  13  14
  15  16
[torch.FloatTensor of size 2x2x2x2]

Notice that change in value of an element in x reflects in x_. It is because view() does exactly what is says it will do. It creates a view of the tensor, the underlying storage is same for x and x_

Statistics

x  = torch.range(1, 16)
x_ = x.view(4,4)
print(x_)

  1   2   3   4
  5   6   7   8
  9  10  11  12
 13  14  15  16
[torch.FloatTensor of size 4x4]

print(x_.sum(dim = 0))

 28  32  36  40
[torch.FloatTensor of size 1x4]

print(x_.sum(dim = 1))

 10
 26
 42
 58
[torch.FloatTensor of size 4x1]

x_ = x.view(2,2,4)
print(x_)

(0 ,.,.) =
   1   2   3   4
   5   6   7   8

(1 ,.,.) =
   9  10  11  12
  13  14  15  16
[torch.FloatTensor of size 2x2x4]

print(x_.sum(dim = 0))

(0 ,.,.) =
  10  12  14  16
  18  20  22  24
[torch.FloatTensor of size 1x2x4]

print(x_.sum(dim = 1))

(0 ,.,.) =
   6   8  10  12

(1 ,.,.) =
  22  24  26  28
[torch.FloatTensor of size 2x1x4]

print(x_.sum(dim = 2))

(0 ,.,.) =
  10
  26

(1 ,.,.) =
  42
  58
[torch.FloatTensor of size 2x2x1]

Matrix Multiplication

mm() is name. See how it is different from normal elementwise multiplication, like we used to do in linear algebra class?

#lets do some matrix multiplications
w = torch.Tensor([[10, 20],
                  [30, 40]])

x = torch.Tensor([[1,2],
                  [3,4]])

print(w.mm(x))

  70  100
 150  220
[torch.FloatTensor of size 2x2]

w = torch.Tensor([[10, 20],
                  [30, 40],
                  [50, 60]])

x = torch.Tensor([[1,2,5],
                  [3,4,6]])
print(w.mm(x))

  70  100  170
 150  220  390
 230  340  610
[torch.FloatTensor of size 3x3]

Indexing and slicing

#Indexing and slicing
x = torch.range(1, 64)
print(x)

  1
  2
  3
  4
  5
  .
  .
  .
 61
 62
 63
 64

[torch.FloatTensor of size 64]


x_ = x.view(4,4,4)
print(x_)

(0 ,.,.) =
   1   2   3   4
   5   6   7   8
   9  10  11  12
  13  14  15  16

(1 ,.,.) =
  17  18  19  20
  21  22  23  24
  25  26  27  28
  29  30  31  32

(2 ,.,.) =
  33  34  35  36
  37  38  39  40
  41  42  43  44
  45  46  47  48

(3 ,.,.) =
  49  50  51  52
  53  54  55  56
  57  58  59  60
  61  62  63  64
[torch.FloatTensor of size 4x4x4]

print(x_[1, 1, :])

 21
 22
 23
 24
[torch.FloatTensor of size 4]

Masking

#the expression 'x_ % 4 == 0' creates a mask
print(x_ % 4 == 0)

(0 ,.,.) =
  0  0  0  1
  0  0  0  1
  0  0  0  1
  0  0  0  1

(1 ,.,.) =
  0  0  0  1
  0  0  0  1
  0  0  0  1
  0  0  0  1

(2 ,.,.) =
  0  0  0  1
  0  0  0  1
  0  0  0  1
  0  0  0  1

(3 ,.,.) =
  0  0  0  1
  0  0  0  1
  0  0  0  1
  0  0  0  1
[torch.ByteTensor of size 4x4x4]

# Use the mask to extract just those elements

x_[0][(x_%4 == 0)[0]]

  4
  8
 12
 16
[torch.FloatTensor of size 4]


#more grander masking example

x = torch.range(1, 64)
print(x)

  1
  2
  3
  4
  5
  .
  .
  .
 61
 62
 63
 64

[torch.FloatTensor of size 64]

x_ = x.view(8,8)
print(x_)

    1     2     3     4     5     6     7     8
    9    10    11    12    13    14    15    16
   17    18    19    20    21    22    23    24
   25    26    27    28    29    30    31    32
   33    34    35    36    37    38    39    40
   41    42    43    44    45    46    47    48
   49    50    51    52    53    54    55    56
   57    58    59    60    61    62    63    64
[torch.FloatTensor of size 8x8]

x_ind = torch.eye(8).byte()
print(x_ind)

    1     0     0     0     0     0     0     0
    0     1     0     0     0     0     0     0
    0     0     1     0     0     0     0     0
    0     0     0     1     0     0     0     0
    0     0     0     0     1     0     0     0
    0     0     0     0     0     1     0     0
    0     0     0     0     0     0     1     0
    0     0     0     0     0     0     0     1
[torch.ByteTensor of size 8x8]

print(x[x_ind])

  1
 10
 19
 28
 37
 46
 55
 64
[torch.FloatTensor of size 8]

Please leave your comments below.

Take a look into how the data looks like

%matplotlib inline
import matplotlib.pyplot as plt
from mpl_toolkits.axes_grid1 import ImageGrid
from PIL import Image

fig = plt.figure(1,(10., 50.))
grid = ImageGrid(fig, 111,
                 nrows_ncols=(2 , 5),
                 axes_pad=0.1)

for i, (data, target) in enumerate(dataset):
    grid[i].matshow(Image.fromarray(data.numpy()))
    grid[i].tick_params(axis='both', which='both', length=0, labelsize=0)
plt.show()

We have a set of 10 images of numbers 0..9. We want to make a neural network to predict what is the number on the image.

DATASET - MODEL - OUTPUT

To understand the network and its training process, it is helpful to see the holy trinity INPUT-MODEL-OUTPUT

fig = plt.figure(1, (16., 16.))
grid = ImageGrid(fig, 111,
                     nrows_ncols=(1, 3),
                     axes_pad=0.1)


data = [data.view(-1) for data, target in dataset]
data = torch.stack(data)

target = [target.view(-1) for data, target in dataset]
target = torch.stack(target).squeeze()
grid[0].matshow(Image.fromarray(data.numpy()))
grid[0].set_title('DATASET', fontsize=24)
grid[0].set_ylabel('10', fontsize=24)
grid[0].set_xlabel('25', fontsize=24)
grid[0].tick_params(axis='both', which='both', length=0, labelsize=0)

grid[1].matshow(Image.fromarray(model.output_layer.weight.data.numpy()))
grid[1].set_title('MODEL', fontsize=24)
grid[1].set_xlabel('25', fontsize=24)
grid[1].tick_params(axis='both', which='both', length=0, labelsize=0)


output = model(Variable(data))
grid[2].matshow(Image.fromarray(output.data.numpy()))
grid[2].set_title('OUTPUT', fontsize=24)
grid[2].set_xlabel('10', fontsize=24)
grid[2].tick_params(axis='both', which='both', length=0, labelsize=0)

plt.show()

Lets try to understand what is in the picture above.

The first one is the collection of all the data that we have. The second one is the matrix of weights connecting the input of 25 input neurons to 10 output neurons. And the last one we will get to it little later.

What is special about 25 and 10 here?

Nothing. Our dataset is a set of images of numbers each having a size of 5x5 ==> 25. And we have how many different numbers a hand? 0,1,2...9 ==> 10 numbers or 10 different classes of output(this will become clear in the next post)

What is that weird picture on the left, having weird

• zero in the top-left,
• and three on the bottom-right
• and some messed up fours and eights in the middle.

Let get to it. Look the picture below.

fig = plt.figure(1,(12., 12.))
grid = ImageGrid(fig, 111,
                 nrows_ncols=(2 , 5),
                 axes_pad=0.1)

for i, (d, t) in enumerate(dataset):
    grid[i].matshow(Image.fromarray(d.numpy()))
    grid[i].tick_params(axis='both', which='both', length=0, labelsize=0)

plt.show()

fig = plt.figure(1, (100., 10.))
grid = ImageGrid(fig, 111,
                     nrows_ncols=(len(dataset), 1),
                     axes_pad=0.1)


data = [data.view(1, -1) for data, target in dataset]

for i, d in enumerate(data):
    grid[i].matshow(Image.fromarray(d.numpy()))
    grid[i].set_ylabel('{}'.format(i), fontsize=36)
    grid[i].tick_params(axis='both', which='both', length=0, labelsize=0)

Voila!! We have just arranged the image matrix into a vector. TODO why?

This is important to remember, a simple neural network looks at the input and try to figure out which class does this input belong to

In our case inputs are the images of numbers, and outputs are how similar are the classes to the input. The output neuron with highest value is closer(very similar) to the input and the output neuron with least value is very NOT similar to the input. The inputs are real valued - it can take any numerical value but the output is discrete, a whole number corresponding to index of the neuron with largest numerical value. Also note that output of the network does not mean output of neurons.

For example after training, if we feed the image of number 3, the output neurons corresponding to 3, 8, 9 and probably 7 will have larger values and the output neurons corresponding to 1 and 6 will have the least value. Don't worry if you don't understand why, it will become clearer as we go on.

How many correct predictions without any training

Too much theory, lets get our hands dirty. Let see how many numbers did our model predicted correctly.

# Remember that output = model(Variable(data))
pred = output.data.max(1)[1].squeeze()
print(pred.size(), target.size())
correct = pred.eq(target.long()).sum()
print('correct: {}/{}'.format(correct, len(dataset)))

torch.Size([10]) torch.Size([10])
correct: 1/10

(N)ONE out of TEN

That is right it predicted none out of ten. We feeded our network with all of our data and asked it to figure what is the number that is in the image. Remember what we learned earlier about output neurons. The neural network tell us which number is present in the image by lighting up that corresponding neuron. Lets say if gave 6, the network will light up the 6th neuron will be the brightest, i.e the 6th neurons value will be the highest compared to all other neurons.

But our network above lit up wrong bulbs, for all the output. None out of ten. But why? Isn't neural network are supposed to smarter? Well yes and no. That is the difference between traditional image processing algorithms and neural networks.

Wait, let me tell you a story, that I heard. During the second world war, there were skilled flight spotter. Their job was to spot and report if any air craft was approaching. As the war got intense, there was need for more spotters and there were lot of volunteers even from schools and colleges but there was very little time to train them. So the skilled spotters, listed out a set of things to look for in the enemy flights and asked the new volunteers to memorize them as part of the training. But the volunteers never got good at spotting. Ooosh, we will continue the story later, lets get back to the point.

In classical image processing systems, we humans think, think and think and think a lot more and come up a set of rules or instructions, just like those skilled spotters. We give those instructions to the system, to make it understand how to process the images to extract information(called features - things to look for in the enemy flight) from them, and then use that information to make further decisions, such predicting what number is in the image. We feed that system with knowledge first before asking it to do anything for us.

But did we feed any knowledge to network? We just told it the input size is 25 and output size is 10. How can you expect someone to guess what is in your hand, by just telling them its size. That is rude of you. Shame on you. Okay okay. How do we make the system more knowledgable about the input? Training. The holy grail of deep learning.

What is training?

We know that the knowledge of the neural network is in the weights of the connections - represented as matrix above. We also know that by multiplying this matrix by an input image vector we will get an output which is a set of scores that describes, how similar the input is to the output neurons.

Imagine giving random values to the weights and feed the network with our data and see whether it predicts all our numbers correctly. If it did, fine and dandy, but if not give random values to the weights again and repeat the process until our network predicts all the numbers correctly. That is training in most simple form.

But think about how long will it take to find such random magical values for every weight in the network to make it work as expected. We don't know that for sure. right? You wanna continue the story. don't you? Alright.

The skilled people tried as much as they can to identify the distinguishing features of the home and enemy air crafts and tried to make the volunteers understand them. It never worked. Then they changes the strategy. They put them on the job and made them learn themselves. i.e every skilled spotter will have ten volunteers and whenever an aircraft is seen, the volunteers will shout the kind of the plane, say 'german'. Then the skilled one, will reveal the correct answer. This technique was extrememly sucessful, a spotter sent in an emergency message not only identifying it as a German aircraft, but also the correct make and model..more

Hey, why don't we try the same with our network? Lets feed the images into it and shout the answer into its tiny little output neurons so that it can update its weights by itself. Now I know you're asking how can we expect, a dumb network which cannot even predict a number in an image to train itself? Well that is where it gets interesting. We can't. Backpropgation to the rescue. It is the algorithm to update the weights of the network on our behalf.

It looks at how difference between output of network and desired output, changes with respect to the weights, and then it modifies the weights based on it. [2]

So now you understand why it predicted none out of ten correctly.

import sys
def test_and_print(model, dataset, title='', plot=True):

    data = [data.view(-1) for data, target in dataset]
    data = torch.stack(data).squeeze()

    target = [target.view(-1) for data, target in dataset]
    target = torch.stack(target).squeeze()
    output = model(Variable(data))

    loss = F.nll_loss(output, Variable(target.long()))

    dataset_img = Image.fromarray(data.numpy())
    model_img   = Image.fromarray(model.output_layer.weight.data.numpy())
    output_img  = Image.fromarray(output.data.numpy())

    pred = output.data.max(1)[1]
    correct = pred.eq(target.long()).sum()

    print('correct: {}/{}, loss:{}'.format(correct, len(dataset), loss.data[0]))
    sys.stdout.flush()

    if plot:
        fig = plt.figure(1,(16., 16.))
        grid = ImageGrid(fig, 111,
                         nrows_ncols=(1 , 3),
                         axes_pad=0.1)

        grid[0].matshow(dataset_img)
        grid[0].set_title('DATASET', fontsize=24)
        grid[0].tick_params(axis='both', which='both', length=0, labelsize=0)
        grid[0].set_ylabel('10', fontsize=24)
        grid[0].set_xlabel('25', fontsize=24)

        grid[1].matshow(model_img)
        grid[1].set_title('MODEL', fontsize=24)
        grid[1].tick_params(axis='both', which='both', length=0, labelsize=0)
        grid[1].set_xlabel('25', fontsize=24)

        grid[2].matshow(output_img)
        grid[2].set_title('OUTPUT', fontsize=24)
        grid[2].tick_params(axis='both', which='both', length=0, labelsize=0)
        grid[2].set_xlabel('10', fontsize=24)

        plt.show()


    return dataset_img, model_img, output_img

Lets take a closer look at DATASET - MODEL - OUTPUT

and understand what those colors mean.[1]

import numpy
fig = plt.figure(1, (80., 80.))
grid = ImageGrid(fig, 111,
                     nrows_ncols=(1, 3),
                     axes_pad=0.5)


data = [data.view(-1) for data, target in dataset]
data = torch.stack(data)

target = [target.view(-1) for data, target in dataset]
target = torch.stack(target)

grid[0].matshow(Image.fromarray(data.numpy()))
grid[0].set_title('DATASET', fontsize=144)
grid[0].tick_params(axis='both', which='both', length=0, labelsize=0)
grid[0].set_ylabel('10', fontsize=144)
grid[0].set_xlabel('25', fontsize=144)
for (x,y), val in numpy.ndenumerate(data.numpy()):
     grid[0].text(y, x, '{:d}'.format(int(val)), ha='center', va='center', fontsize=24,
            bbox=dict(boxstyle='round', facecolor='white', edgecolor='white'))


grid[1].matshow(Image.fromarray(model.output_layer.weight.data.numpy()))
grid[1].set_title('MODEL', fontsize=144)
grid[1].tick_params(axis='both', which='both', length=0, labelsize=0)
grid[1].set_xlabel('25', fontsize=144)
for (x,y), val in numpy.ndenumerate(model.output_layer.weight.data.numpy()):
     grid[1].text(y, x, '{:0.04f}'.format(val), ha='center', va='center',fontsize=16,
            bbox=dict(boxstyle='round', facecolor='white', edgecolor='white'))

output = model(Variable(data))
grid[2].matshow(Image.fromarray(output.data.numpy()))
grid[2].set_title('OUTPUT', fontsize=144)
grid[2].tick_params(axis='both', which='both', length=0, labelsize=0)
grid[2].set_xlabel('10', fontsize=144)

for (x,y), val in numpy.ndenumerate(output.data.numpy()):
     grid[2].text(y, x, '{:0.04f}'.format(val), ha='center', va='center',fontsize=16,
            bbox=dict(boxstyle='round', facecolor='white', edgecolor='white'))


plt.show()