Lab 4-2: Load Data

Author: Seungjae Lee (이승재)님의 slide를 참고하였습니다.

Slicing 1D Array

nums = [0, 1, 2, 3, 4]

print(nums)

[0, 1, 2, 3, 4]

index 2에서 4 전까지 가져와라. (앞 포함, 뒤 비포함)

print(nums[2:4])

[2, 3]

index 2부터 다 가져와라.

print(nums[2:])

[2, 3, 4]

index 2 전까지 가져와라. (역시 뒤는 비포함)

print(nums[:2])

[0, 1]

전부 가져와라

print(nums[:])

[0, 1, 2, 3, 4]

마지막 index 전까지 가져와라. (뒤는 비포함!)

print(nums[:-1])

[0, 1, 2, 3]

assign 도 가능!

nums[2:4] = [8, 9]

print(nums)

[0, 1, 8, 9, 4]

Slicing 2D Array

import numpy as np

b = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

print(b)

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

b[:, 1]

array([ 2,  6, 10])

b[-1]

array([ 9, 10, 11, 12])

b[-1, :]

array([ 9, 10, 11, 12])

b[-1, ...]

array([ 9, 10, 11, 12])

b[0:2, :]

array([[1, 2, 3, 4],
       [5, 6, 7, 8]])

Loading Data from .csv file

import numpy as np

xy = np.loadtxt('data-01-test-score.csv', delimiter=',', dtype=np.float32)
xy

array([[ 73.,  80.,  75., 152.],
       [ 93.,  88.,  93., 185.],
       [ 89.,  91.,  90., 180.],
       [ 96.,  98., 100., 196.],
       [ 73.,  66.,  70., 142.],
       [ 53.,  46.,  55., 101.],
       [ 69.,  74.,  77., 149.],
       [ 47.,  56.,  60., 115.],
       [ 87.,  79.,  90., 175.],
       [ 79.,  70.,  88., 164.],
       [ 69.,  70.,  73., 141.],
       [ 70.,  65.,  74., 141.],
       [ 93.,  95.,  91., 184.],
       [ 79.,  80.,  73., 152.],
       [ 70.,  73.,  78., 148.],
       [ 93.,  89.,  96., 192.],
       [ 78.,  75.,  68., 147.],
       [ 81.,  90.,  93., 183.],
       [ 88.,  92.,  86., 177.],
       [ 78.,  83.,  77., 159.],
       [ 82.,  86.,  90., 177.],
       [ 86.,  82.,  89., 175.],
       [ 78.,  83.,  85., 175.],
       [ 76.,  83.,  71., 149.],
       [ 96.,  93.,  95., 192.]], dtype=float32)

x_data = xy[:, 0:-1]
y_data = xy[:, [-1]]

print(x_data.shape) # x_data shape
print(len(x_data))  # x_data 길이
print(x_data[:5])   # 첫 다섯 개

(25, 3)
25
[[ 73.  80.  75.]
 [ 93.  88.  93.]
 [ 89.  91.  90.]
 [ 96.  98. 100.]
 [ 73.  66.  70.]]

print(y_data.shape) # y_data shape
print(len(y_data))  # y_data 길이
print(y_data[:5])   # 첫 다섯 개

(25, 1)
25
[[152.]
 [185.]
 [180.]
 [196.]
 [142.]]

Imports

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

# For reproducibility
torch.manual_seed(1)

<torch._C.Generator at 0x7f313b60b530>

Low-level Implementation

# 데이터
x_train = torch.FloatTensor(x_data)
y_train = torch.FloatTensor(y_data)

W, b 값을 찾아야 한다. 우선 가중치들을 초기화시키자. 이후, requries_grad = True가 인자로 주어지는데, 이 변수는 학습을 통해 계속 값이 변경되는 변수임을 의미한다.

# 모델 초기화
W = torch.zeros((3, 1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)

이후 가설과 비용함수를 선언한다. 그리고 SGD로 경사 하강법을 구현해보자.

1. optimizer.zero_grad()를 실행함으로써 미분을 통해 얻은 기울기를 0으로 초기화한다.

• 기울기를 초기화해야만 새로운 가중치 편향에 대해 새로운 기울기를 구할 수 있다.
• 왜냐하면 파이토치는 미분을 통해 얻은 기울기를 이전에 계산된 기울기 값에 누적시키는 특징이 있기 때문이다.

2. 그 후 cost.backword() 함수를 호출하면 가중치 W, 편향 b에 대한 기울기가 계산된다.
3. 이후 optimizer의 ,step()함수를 호출하여 인수로 들어갔던 W, b에서 리턴되는 변수들의 기울기에 학습률을 곱해 빼줌으로써 업데이트된다.

# optimizer 설정
optimizer = optim.SGD([W, b], lr=1e-5)

nb_epochs = 20
for epoch in range(nb_epochs + 1):
    
    # H(x) 계산
    hypothesis = x_train.matmul(W) + b # or .mm or @

    # cost 계산
    cost = torch.mean((hypothesis - y_train) ** 2)

    # cost로 H(x) 개선
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()

    # 100번마다 로그 출력
    print('Epoch {:4d}/{} Cost: {:.6f}'.format(
        epoch, nb_epochs, cost.item()
    ))

Epoch    0/20 Cost: 26811.960938
Epoch    1/20 Cost: 9920.530273
Epoch    2/20 Cost: 3675.298828
Epoch    3/20 Cost: 1366.260620
Epoch    4/20 Cost: 512.542480
Epoch    5/20 Cost: 196.896622
Epoch    6/20 Cost: 80.190994
Epoch    7/20 Cost: 37.038700
Epoch    8/20 Cost: 21.081343
Epoch    9/20 Cost: 15.178759
Epoch   10/20 Cost: 12.993679
Epoch   11/20 Cost: 12.183025
Epoch   12/20 Cost: 11.880536
Epoch   13/20 Cost: 11.765958
Epoch   14/20 Cost: 11.720850
Epoch   15/20 Cost: 11.701437
Epoch   16/20 Cost: 11.691511
Epoch   17/20 Cost: 11.685117
Epoch   18/20 Cost: 11.680004
Epoch   19/20 Cost: 11.675379
Epoch   20/20 Cost: 11.670951

High-level Implementation with nn.Module

class MultivariateLinearRegressionModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.linear = nn.Linear(3, 1)

    def forward(self, x):
        return self.linear(x)

# 데이터
x_train = torch.FloatTensor(x_data)
y_train = torch.FloatTensor(y_data)
# 모델 초기화
model = MultivariateLinearRegressionModel()
# optimizer 설정
optimizer = optim.SGD(model.parameters(), lr=1e-5)

nb_epochs = 20
for epoch in range(nb_epochs+1):
    
    # H(x) 계산
    prediction = model(x_train)
    
    # cost 계산
    cost = F.mse_loss(prediction, y_train)
    
    # cost로 H(x) 개선
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()
    
    # 20번마다 로그 출력
    print('Epoch {:4d}/{} Cost: {:.6f}'.format(
        epoch, nb_epochs, cost.item()
    ))

Epoch    0/20 Cost: 28388.000000
Epoch    1/20 Cost: 10504.286133
Epoch    2/20 Cost: 3892.179688
Epoch    3/20 Cost: 1447.497314
Epoch    4/20 Cost: 543.628357
Epoch    5/20 Cost: 209.440048
Epoch    6/20 Cost: 85.878799
Epoch    7/20 Cost: 40.191814
Epoch    8/20 Cost: 23.297268
Epoch    9/20 Cost: 17.048059
Epoch   10/20 Cost: 14.734761
Epoch   11/20 Cost: 13.876624
Epoch   12/20 Cost: 13.556563
Epoch   13/20 Cost: 13.435411
Epoch   14/20 Cost: 13.387821
Epoch   15/20 Cost: 13.367404
Epoch   16/20 Cost: 13.357059
Epoch   17/20 Cost: 13.350419
Epoch   18/20 Cost: 13.345175
Epoch   19/20 Cost: 13.340427
Epoch   20/20 Cost: 13.335882

Dataset and DataLoader

너무 데이터가 크면 x_data, y_data 를 전부 다 가져오지 말고, 필요한 배치만 가져올 수 밖에 없다.

PyTorch Data Loading and Processing tutorial