Torch basics

In [12]:

import torch
from torch import nn

import torch from torch import nn

In [10]:

t1 = torch.tensor([1,2,3])
print(t1)
t1 + t1

t1 = torch.tensor([1,2,3]) print(t1) t1 + t1

tensor([1, 2, 3])

Out[10]:

tensor([2, 4, 6])

In [5]:

torch.zeros(2,3)

torch.zeros(2,3)

Out[5]:

tensor([[0., 0., 0.],
        [0., 0., 0.]])

In [6]:

torch.rand(3,2)

torch.rand(3,2)

Out[6]:

tensor([[0.8699, 0.3281],
        [0.8116, 0.0608],
        [0.8737, 0.3716]])

In [8]:

t1 * 2

t1 * 2

Out[8]:

tensor([2, 4, 6])

In [9]:

t1 * t1

t1 * t1

Out[9]:

tensor([1, 4, 9])

In [11]:

torch.matmul(t1, t1)

torch.matmul(t1, t1)

Out[11]:

tensor(14)

In [22]:

x = torch.rand(3, 2, requires_grad=True)
y = torch.rand(3, 2, requires_grad=True)
x, y

x = torch.rand(3, 2, requires_grad=True) y = torch.rand(3, 2, requires_grad=True) x, y

Out[22]:

(tensor([[0.3861, 0.0548],
         [0.5297, 0.3745],
         [0.9025, 0.7384]], requires_grad=True),
 tensor([[0.7128, 0.5378],
         [0.5909, 0.7944],
         [0.7737, 0.7306]], requires_grad=True))

In [31]:

z = (x*y).sum()
z

z = (x*y).sum() z

Out[31]:

tensor(2.1529, grad_fn=<SumBackward0>)

In [32]:

z.backward()

z.backward()

In [33]:

x.grad, y.grad

x.grad, y.grad

Out[33]:

(tensor([[0.7128, 0.5378],
         [0.5909, 0.7944],
         [0.7737, 0.7306]]),
 tensor([[0.3861, 0.0548],
         [0.5297, 0.3745],
         [0.9025, 0.7384]]))

In [35]:

import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

import torch.nn as nn import torch.optim as optim from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler

In [109]:

iris = load_iris()
x, y = iris.data, iris.target
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)
x_train.shape, x_test.shape

iris = load_iris() x, y = iris.data, iris.target x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3) x_train.shape, x_test.shape

Out[109]:

((105, 4), (45, 4))

In [93]:

scaler = StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)

scaler = StandardScaler() x_train = scaler.fit_transform(x_train) x_test = scaler.transform(x_test)

In [94]:

class BaseNN(nn.Module):
    def __init__(self, inputsize, hiddensize, outputsize):
        super().__init__()
        self.l1 = nn.Linear(inputsize, hiddensize)
        self.relu = nn.ReLU()
        self.out = nn.Linear(hiddensize, outputsize)

    def forward(self, x):
        x = self.l1(x)
        x = self.relu(x)
        x = self.out(x)
        return x

class BaseNN(nn.Module): def __init__(self, inputsize, hiddensize, outputsize): super().__init__() self.l1 = nn.Linear(inputsize, hiddensize) self.relu = nn.ReLU() self.out = nn.Linear(hiddensize, outputsize) def forward(self, x): x = self.l1(x) x = self.relu(x) x = self.out(x) return x

In [95]:

inputsize = x.shape[1]
hidden = 10
outputsize = len(iris.target_names)

model = BaseNN(inputsize, hidden, outputsize)

inputsize = x.shape[1] hidden = 10 outputsize = len(iris.target_names) model = BaseNN(inputsize, hidden, outputsize)

In [127]:

loss_func = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

loss_func = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.01)

In [98]:

x_train_tensor = torch.FloatTensor(x_train)
y_train_tensor = torch.LongTensor(y_train)

x_train_tensor = torch.FloatTensor(x_train) y_train_tensor = torch.LongTensor(y_train)

In [131]:

n_epoches = 1000

for epoch in range(n_epoches):
    curr_pred = model(x_train_tensor)
    loss = loss_func(curr_pred, y_train_tensor)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 100 == 0:
        print(loss.item())

n_epoches = 1000 for epoch in range(n_epoches): curr_pred = model(x_train_tensor) loss = loss_func(curr_pred, y_train_tensor) optimizer.zero_grad() loss.backward() optimizer.step() if epoch % 100 == 0: print(loss.item())

0.9101477265357971
0.8511947393417358
0.7693083882331848
0.7287635207176208
0.7015920877456665
0.6796717047691345
0.6636332869529724
0.652461051940918
0.6425111889839172
0.6372277140617371

In [132]:

with torch.no_grad():
    x_test_tensor = torch.FloatTensor(x_test)
    y_test_tensor = torch.LongTensor(y_test)
    outputs = model(x_test_tensor)
    _, predicted = torch.max(outputs, 1)
    acc = (predicted == y_test_tensor).sum().item()/len(y_test)
    print(acc)

with torch.no_grad(): x_test_tensor = torch.FloatTensor(x_test) y_test_tensor = torch.LongTensor(y_test) outputs = model(x_test_tensor) _, predicted = torch.max(outputs, 1) acc = (predicted == y_test_tensor).sum().item()/len(y_test) print(acc)

0.24444444444444444

In [ ]: