In [1]:

import numpy as np
import torch
import os

In [3]:

x = torch.arange(start=10, end=20, step=4)
y = torch.arange(start=5, end=15, step=4)

x.shape, y.shape

Out[3]:

(torch.Size([3]), torch.Size([3]))

In [5]:

Out[5]:

tensor([10, 14, 18])

In [6]:

Out[6]:

tensor([ 5,  9, 13])

In [4]:

x + y

Out[4]:

tensor([15, 23, 31])

In [7]:

x - y

Out[7]:

tensor([5, 5, 5])

In [8]:

x * y #<< Element wise multiplication

Out[8]:

tensor([ 50, 126, 234])

In [24]:

torch.dot(x, y)

Out[24]:

tensor(410)

In [26]:

sum([ 50, 126, 234])

Out[26]:

In [9]:

x / y #<< Element wise division

Out[9]:

tensor([2.0000, 1.5556, 1.3846])

In [12]:

z = torch.ones(3)
z

Out[12]:

tensor([1., 1., 1.])

In [13]:

z = z + x
z

Out[13]:

tensor([11., 15., 19.])

In [15]:

## inplace addition
z.add_(x)
z

Out[15]:

tensor([31., 43., 55.])

In [16]:

x.pow(2)

Out[16]:

tensor([100, 196, 324])

In [17]:

x**2

Out[17]:

tensor([100, 196, 324])

In [18]:

x > 0

Out[18]:

tensor([True, True, True])

In [19]:

# Matrix multpltplication

A = torch.rand(size=(3,5))
B = torch.rand(size=(5,4))

A @ B 

Out[19]:

tensor([[1.0718, 1.8589, 2.2422, 0.8966],
        [0.6847, 1.3138, 1.1647, 0.5111],
        [1.0766, 1.7835, 1.9630, 0.9556]])

In [20]:

A.matmul(B)

Out[20]:

tensor([[1.0718, 1.8589, 2.2422, 0.8966],
        [0.6847, 1.3138, 1.1647, 0.5111],
        [1.0766, 1.7835, 1.9630, 0.9556]])

In [22]:

X = torch.rand((3,3))
X.matrix_exp()

Out[22]:

tensor([[2.7414, 2.0749, 1.5089],
        [2.2362, 3.0089, 1.1585],
        [2.8463, 2.8138, 2.9833]])

In [23]:

X.matrix_power(2)

Out[23]:

tensor([[1.3818, 1.2499, 0.7981],
        [1.1508, 1.3000, 0.8949],
        [1.7752, 1.8222, 1.2387]])

In [27]:

# Broadcasting

A

Out[27]:

tensor([[0.5417, 0.4911, 0.7433, 0.4764, 0.7647],
        [0.3658, 0.6612, 0.0644, 0.5575, 0.2324],
        [0.0760, 0.9765, 0.6866, 0.5266, 0.8332]])

In [28]:

A + 1

Out[28]:

tensor([[1.5417, 1.4911, 1.7433, 1.4764, 1.7647],
        [1.3658, 1.6612, 1.0644, 1.5575, 1.2324],
        [1.0760, 1.9765, 1.6866, 1.5266, 1.8332]])

In [29]:

A - 1

Out[29]:

tensor([[-0.4583, -0.5089, -0.2567, -0.5236, -0.2353],
        [-0.6342, -0.3388, -0.9356, -0.4425, -0.7676],
        [-0.9240, -0.0235, -0.3134, -0.4734, -0.1668]])

In [30]:

A * 5

Out[30]:

tensor([[2.7087, 2.4553, 3.7167, 2.3822, 3.8236],
        [1.8292, 3.3058, 0.3218, 2.7874, 1.1621],
        [0.3798, 4.8824, 3.4330, 2.6328, 4.1660]])

In [32]:

A.shape

Out[32]:

torch.Size([3, 5])

In [35]:

C = torch.ones((1,5))
C

Out[35]:

tensor([[1., 1., 1., 1., 1.]])

In [34]:

A - C

Out[34]:

tensor([[-0.4583, -0.5089, -0.2567, -0.5236, -0.2353],
        [-0.6342, -0.3388, -0.9356, -0.4425, -0.7676],
        [-0.9240, -0.0235, -0.3134, -0.4734, -0.1668]])

In [36]:

A + C

Out[36]:

tensor([[1.5417, 1.4911, 1.7433, 1.4764, 1.7647],
        [1.3658, 1.6612, 1.0644, 1.5575, 1.2324],
        [1.0760, 1.9765, 1.6866, 1.5266, 1.8332]])

In [38]:

D = torch.ones((3, 1))
D

Out[38]:

tensor([[1.],
        [1.],
        [1.]])

In [39]:

A - D

Out[39]:

tensor([[-0.4583, -0.5089, -0.2567, -0.5236, -0.2353],
        [-0.6342, -0.3388, -0.9356, -0.4425, -0.7676],
        [-0.9240, -0.0235, -0.3134, -0.4734, -0.1668]])

In [40]:

A + D

Out[40]:

tensor([[1.5417, 1.4911, 1.7433, 1.4764, 1.7647],
        [1.3658, 1.6612, 1.0644, 1.5575, 1.2324],
        [1.0760, 1.9765, 1.6866, 1.5266, 1.8332]])

In [42]:

Out[42]:

tensor([[1.],
        [1.],
        [1.]])

In [43]:

torch.sum(D)

Out[43]:

tensor(3.)

In [44]:

torch.sum(A)

Out[44]:

tensor(7.9974)

In [45]:

Out[45]:

tensor([[0.5417, 0.4911, 0.7433, 0.4764, 0.7647],
        [0.3658, 0.6612, 0.0644, 0.5575, 0.2324],
        [0.0760, 0.9765, 0.6866, 0.5266, 0.8332]])

In [46]:

torch.max(A)

Out[46]:

tensor(0.9765)

In [47]:

torch.min(A)

Out[47]:

tensor(0.0644)

In [48]:

torch.min(A, dim=1)

Out[48]:

torch.return_types.min(
values=tensor([0.4764, 0.0644, 0.0760]),
indices=tensor([3, 2, 0]))

In [49]:

torch.max(A, dim=1) # row wise max 

Out[49]:

torch.return_types.max(
values=tensor([0.7647, 0.6612, 0.9765]),
indices=tensor([4, 1, 1]))

In [50]:

torch.max(A, dim=0) # col wise max

Out[50]:

torch.return_types.max(
values=tensor([0.5417, 0.9765, 0.7433, 0.5575, 0.8332]),
indices=tensor([0, 2, 0, 1, 2]))

In [52]:

torch.abs(-A)

Out[52]:

tensor([[0.5417, 0.4911, 0.7433, 0.4764, 0.7647],
        [0.3658, 0.6612, 0.0644, 0.5575, 0.2324],
        [0.0760, 0.9765, 0.6866, 0.5266, 0.8332]])

In [54]:

Out[54]:

tensor([[0.5417, 0.4911, 0.7433, 0.4764, 0.7647],
        [0.3658, 0.6612, 0.0644, 0.5575, 0.2324],
        [0.0760, 0.9765, 0.6866, 0.5266, 0.8332]])

In [53]:

torch.argmax(A)

Out[53]:

tensor(11)

In [58]:

torch.argmax(A, dim=1) # row wise argmax

Out[58]:

tensor([4, 1, 1])

In [59]:

torch.argmax(A, dim=0) # col wise argmax

Out[59]:

tensor([0, 2, 0, 1, 2])

In [55]:

torch.argmin(A)

Out[55]:

tensor(7)

In [56]:

torch.mean(A)

Out[56]:

tensor(0.5332)

In [60]:

torch.mean(A, dim=1) # row wise mean

Out[60]:

tensor([0.6035, 0.3763, 0.6198])

In [61]:

torch.mean(A, dim=0) # col wise mean

Out[61]:

tensor([0.3278, 0.7096, 0.4981, 0.5202, 0.6101])

In [62]:

Out[62]:

tensor([[0.5417, 0.4911, 0.7433, 0.4764, 0.7647],
        [0.3658, 0.6612, 0.0644, 0.5575, 0.2324],
        [0.0760, 0.9765, 0.6866, 0.5266, 0.8332]])

In [67]:

D = torch.ones(A.shape)
D

Out[67]:

tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])

In [68]:

torch.eq(A, D)

Out[68]:

tensor([[False, False, False, False, False],
        [False, False, False, False, False],
        [False, False, False, False, False]])

In [69]:

torch.eq(D, D)

Out[69]:

tensor([[True, True, True, True, True],
        [True, True, True, True, True],
        [True, True, True, True, True]])

In [70]:

torch.sort(A)

Out[70]:

torch.return_types.sort(
values=tensor([[0.4764, 0.4911, 0.5417, 0.7433, 0.7647],
        [0.0644, 0.2324, 0.3658, 0.5575, 0.6612],
        [0.0760, 0.5266, 0.6866, 0.8332, 0.9765]]),
indices=tensor([[3, 1, 0, 2, 4],
        [2, 4, 0, 3, 1],
        [0, 3, 2, 4, 1]]))

In [75]:

torch.clamp(A, min=0.5)

Out[75]:

tensor([[0.5417, 0.5000, 0.7433, 0.5000, 0.7647],
        [0.5000, 0.6612, 0.5000, 0.5575, 0.5000],
        [0.5000, 0.9765, 0.6866, 0.5266, 0.8332]])

In [ ]: