import numpy as np
print(np.__version__)

1.26.4

import torch
print(torch.__version__)

2.2.2

import numpy as np
import torch
import torch.nn as nn
from torchvision import datasets
from torchvision import transforms
from torch.utils.data.sampler import SubsetRandomSampler

#credit to https://jamesmccaffrey.wordpress.com/2020/08/07/displaying-cifar-10-images-using-pytorch/

import torch as T
import torchvision as tv
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

def imshow(img):
  img = img / 2 + 0.5   # unnormalize
  npimg = img.numpy()   # convert from tensor
  plt.imshow(np.transpose(npimg, (1, 2, 0))) 
  plt.show()

transform = transforms.Compose( [transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5),
  (0.5, 0.5, 0.5))])

trainset = tv.datasets.CIFAR10(root='.\\data', train=True, download=True, transform=transform)
trainloader = T.utils.data.DataLoader(trainset,
batch_size=100, shuffle=False, num_workers=1)

# classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog',
#   'frog', 'horse', 'ship', 'truck')

# get first 100 training images
dataiter = iter(trainloader)
imgs, lbls = next(dataiter)

for i in range(100):  # show just the frogs
    if lbls[i] == 1:  # 1 = car
      imshow(tv.utils.make_grid(imgs[i]))

vec1 = [1,2,3]

print(vec1)

[1, 2, 3]

import numpy as np

vec2 = np.array(vec1)
print(vec2)

[1 2 3]

import time
import numpy as np

size_of_vec = int(1e6)

def pure_python_version():
    t1 = time.time()
    X = range(size_of_vec)
    Y = range(size_of_vec)
    Z = [X[i] + Y[i] for i in range(len(X)) ]
    return time.time() - t1

t1 = pure_python_version()
print('Pure Python time: {:.6f}'.format(t1))

Pure Python time: 0.228560

def numpy_version():
    t1 = time.time()
    X = np.arange(size_of_vec)
    Y = np.arange(size_of_vec)
    Z = X + Y
    return time.time() - t1

t2 = numpy_version()
print('Numpy time: {:.6f}'.format(t2))

Numpy time: 0.015880

a = [[j+3*i for j in range(3)] for i in range(2)]
print(a)

np_array = np.array(a)
print(np_array)

#Initialize from normal python array

import torch
a_data = torch.tensor(a)
print(a_data)

#Initialize from NumPy array


a_np = torch.from_numpy(np_array)
print(a_np)

shape = (2,3,4)
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)

print("Random Tensor: \n {} \n".format(rand_tensor))
print("Ones Tensor: \n {} \n".format(ones_tensor))
print("Zeros Tensor: \n {}".format(zeros_tensor))

tensor = torch.rand(3,4)

print("Shape of tensor: {}".format(tensor.shape))
print("Datatype of tensor: {}".format(tensor.dtype))
print("Device tensor is stored on: {}".format(tensor.device))

a = [[j+3*i for j in range(3)] for i in range(2)]
a_tensor = torch.tensor(a)
print(a_tensor)

# example of slicing
print(a_tensor[:,1])

print(a_tensor[1,0].item())

torch.manual_seed(42)

# Generate random integers
aa = torch.randint(0, 100, (2, 3, 4))
print(aa)

print(aa)

print(aa[0][0][0])

print(aa.shape)

a = [[i+3*j for i in range(3)] for j in range(2)]
b = [[j+2*i for i in range(3)] for j in range(2)]
c = [[int(i+3*j%2==1) for i in range(2)] for j in range(3)]

a_tensor = torch.tensor(a)
b_tensor = torch.tensor(b)
c_tensor = torch.tensor(c)
print(a_tensor)
print(b_tensor)
print(c_tensor)

# This computes the ****** product
print(f"a_tensor.mul(b_tensor) \n {a_tensor.mul(b_tensor)} \n")
# Alternative syntax:
print(f"a_tensor * b_tensor \n {a_tensor * b_tensor}")

print(f"tensor.matmul(tensor.T) \n {tensor.matmul(tensor.T)} \n")
# Alternative syntax:
print(f"tensor @ tensor.T \n {tensor @ tensor.T}")

# This transposes a tensor
print('Original tensor \n {} \n'.format(a_tensor))
print('Transposed tensor \n {} \n'.format(a_tensor.T))
print('Another way to transpose the tensor \n {} \n'.format(torch.transpose(a_tensor, dim0=0, dim1=1)))

x = torch.tensor([[[i for k in range(4)] for j in range(3)] for i in range(2)])
print(x.shape)
print("Original Vector:")
print(x)

print("Original Vector:")
print(x)
print("Transposed Vector (Dim = ?):")
xt=torch.transpose(x, dim0=0, dim1=1)
print(xt)
print(print(xt.shape))

print(x.T)

a = torch.ones([4,4])
b = torch.log(a)
print(a)
print(b)

print(tensor, "\n")
tensor.add_(5)
print(tensor)

# Convert from tensor to NumPy array

tensor = torch.ones(4, 4)
print(tensor)
print(tensor.numpy())

# Covert from NumPy array to torch:

n = np.ones(5)
t = torch.from_numpy(n)
print(t)

np.add(n, 1, out=n)
print(f"t: {t}")
print(f"n: {n}")

a = torch.tensor([[4*i+j for j in range(4)] for i in range(4)])
b = a.view(2, 8)
print(a)
print(b)

import sys
print("a is sized: " + str(sys.getsizeof(a)))
print("b is sized: " + str(sys.getsizeof(b)))

c = torch.tensor([[4*i+j for j in range(100)] for i in range(100)])
print("c is sized: " + str(sys.getsizeof(c)))

print("The data in 'a' is sized: " + str(a.element_size() * a.nelement()))
print("The data in 'b' is sized: " + str(b.element_size() * b.nelement()))
print("The data in 'c' is sized: " + str(c.element_size() * c.nelement()))

a = torch.tensor([[4*i+j for j in range(4)] for i in range(4)])
b = a.view(-1, 16)
c = torch.tensor([[5*i+j for j in range(5)] for i in range(5)])

def same_storage(x, y):
    return x.storage().data_ptr() == y.storage().data_ptr()

print("Do 'a' and 'b' share a view? " + str(same_storage(a, b)))
print("Do 'a' and 'c' share a view? " + str(same_storage(a, c)))

a = torch.randn(2,3)
b = torch.cat((a,a,a),dim=0)
c = torch.cat((a,a,a),dim=1)

print('Original tensor')
print(a.shape)
print(a)
print('')
print('Concatenate in dimension 0 (rows)')
print(b.shape)
print(b)
print('')
print('Concatenate in dimension 1 (rows)')
print(c.shape)
print(c)

a = torch.randn(2,3)
b = torch.stack((a,a,a,a),dim=0)
c = torch.stack((a,a,a,a),dim=1)
d = torch.stack((a,a,a,a),dim=2)

print('Original tensor')
print(a.shape)
print(a)
print('')
print('Stack in dimension 0')
print(b.shape)
print(b)
print('')
print('Stack in dimension 1')
print(c.shape)
print(c)
print('Stack in dimension 2')
print(d.shape)
print(d)

a = torch.randn(2,3)
b = a.unsqueeze(0)

print(a.shape)
print(b.shape)
c = b.squeeze(0)
print(c.shape)

a = torch.zeros([2, 5], dtype=torch.int32)
print(a)
# a.element_size() gives memory (in bytes) per element in tensor
# a.nelement() gives number of elements in a tensor
print(a.element_size() * a.nelement())
b = torch.ones([3, 5], dtype=torch.float64)
print(b)
print(b.element_size() * b.nelement())
# think of this tensor as (# images, # channels, height, width)
c = torch.rand([8, 128, 224, 224], dtype=torch.float64)
print('c takes {} MB'.format(c.element_size() * c.nelement()/(2**20)))

x = torch.ones((2,4), dtype=torch.int32)
print(x)
y = x.to(torch.float64)
print(y)

Creates tensor views	Creates tensor copies
`view()` - reshapes tensor	`clone()` - explicity creates a copy
`narrow()` - extracts contiguous subset of tensor	`detach()` - creates a new tesnor detached from computational graph
`transpose()` - swaps two dimensions of a tensor	`copy()` - copies data from one tensor to another
`permute()` - generalizes transpose to many dimensions	`to()` - copies data to gpu
`squeeze()` - removes dimensions of size 1
`unsqueeze()` - add dimension of size 1
`as_strided()` - creates a view with non-contiguous strides (advanced)

Lecture 0 - Course Intro and PyTorch Basics¶

ECE364 - Programming Methods for Machine Learning¶

Nickvash Kani¶

Slides based off prior lectures by Alex Schwing, Aigou Han, Farzas Kamalabadi, Corey Snyder. All mistakes are my own!¶

Lecture plan:¶

Part 1: Introduction to PyTorch¶

What is PyTorch?¶

Why use PyTorch¶

Part 2: Feeling out PyTorch¶

Software installation and initialization¶

Datasets¶

Small Torch Model¶

Jupyter notebook demonstration (on Google colab)¶

Part 3: Introduction to Tensors¶

What about tensors?¶

How to create a Torch tensor¶

Useful tensor initializations:¶

Some simple Tensor Attributes¶

Tensor indexing¶

Basic Tensor Operations¶

Elementwise operations¶

In-place operations¶

Interaction with NumPy¶

Tensor Views¶

Tensor strides¶

Combining Tensors¶

Adding dimensions¶

Datatypes of tensors¶

Converting from one datatype to another¶