Pytorch

Question 1

How does one create a tensor in pytorch?

Answer 1

x_tensor = torch.tensor(data) # directly from data
print(x_tensor)

np_array = np.array(data)
x_tensor = torch.from_numpy(np_array) # from numpy, this time infers a dtype
print(x_tensor)

x_ones_tensor = torch.ones_like(x_tensor) # this gets the shape of the data passed, then gives ones array
print(x_ones_tensor)

x_rand_tensor = torch.rand_like(x_tensor, dtype=torch.float) # this does the same as above, but random values
print(x_rand_tensor)

Question 2

How do you get the shape of a tensor? type? device?

Answer 2

tensor.shape
tensor.dtype
tensor.device

Question 3

How do you slice a tensor?

Answer 3

tensor[row,column]

Question 4

How do you concatenate a tensor?

Answer 4

t1 = torch.cat([tensor,tensor,tensor], dim=1)

Question 5

How do we multiply tensors?

Answer 5

tensor.mul(tensor) #element-wise

tensor*tensor # element wise

tensor.matmul(tensor) # matrix mult

tensor @ tensor # matrix mult

Question 6

What are significance of functions with a “_” in pytorch?

Answer 6

They are in place operations

Question 7

What is the typical procedure for creating a neural net in pytorch

Answer 7

Define the Model:
Create a subclass of torch.nn.Module, defining the network’s layers in __init__ and the forward pass in forward.

Instantiate the Model:
Create an instance of your model class.

Question 8

Which imports are needed in pytorch when creating a neural net?

Answer 8

import torch
import torch.nn as nn
import torch.nn.functional as F

Question 9

how do you set your device to gpu in pytorch

Answer 9

device = torch.device(‘cuda:0’ if torch.cuda.is_available() else ‘cpu’)

Question 10

What is the general cycle of creating and training a neural net?

Answer 10

1. Define the NN that has some learnable parameters (weights)
2. iterate over a dataset of inputs
3. process the input through the network
4. compute the loss (how far the output is from being correct)
5. propogate gradients back into the networks parameters
6. update the weights of the network, using the SGD update rule: weight=weight - learning_rate*gradient