CHAPTER3 파이토치로 구현하는 ANN 1

# 파이토치 import
import torch

x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(x)

print(f"Size: {x.size()}")
print(f"Shape: {x.shape}")
print(f"랭크(차원): {x.ndimension()}")

# 랭크 늘리기
x = torch.unsqueeze(x, 0)
print(x)

print(f"Size: {x.size()}")
print(f"Shape: {x.shape}")
print(f"랭크(차원): {x.ndimension()}")

# 랭크 줄이기
x = torch.squeeze(x)
print(x)

print(f"Size: {x.size()}")
print(f"Shape: {x.shape}")
print(f"랭크(차원): {x.ndimension()}")

# x를 [3, 3] -> [9]
x = x.view(9)
print(x)

print(f"Size: {x.size()}")
print(f"Shape: {x.shape}")
print(f"랭크(차원): {x.ndimension()}")

ex = torch.tensor([[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]])

print(f"Size: {ex.size()}")
print(f"Shape: {ex.shape}")
print(f"랭크(차원): {ex.ndimension()}")

print(ex.view([-1, 3])) # ex라는 텐서를 (?, 3)의 크기로 변경
print(ex.view([-1, 3]).shape)

import torch

w = torch.randn(5, 3, dtype = torch.float)
x = torch.tensor([[1.0,2.0], [3.0, 4.0], [5.0, 6.0]])
print("w size: ", w.size()) # 5, 3
print("x size: ", x.size())  # 3, 2
print("w: ", w)
print("x: ", x)

b = torch.randn(5, 2, dtype = torch.float)
print("b size: ", b.size())
print("b: ", b)

# 행렬곱 구하기
wx = torch.mm(w, x)
print(f"wx: {wx}")
print(f"wx size: {wx.size()}")

# 행렬 덧셈
result = wx + b
print(f"result: {result}")
print(f"result size: {result.size()}")

w = torch.tensor(1.0, requires_grad = True)
a = w * 3
l = a ** 2

print((w.is_leaf == True) and (w.grad_fn == None))
print((a.is_leaf == True) and (a.grad_fn == None))
print((l.is_leaf == True) and (l.grad_fn == None))
print("---")
print(a.is_leaf)
print(a.grad_fn)
print("---")
print(l.is_leaf)
print(l.grad_fn)

l.backward()
print(f"l을 w로 미분한 값은 {w.grad}")

import torch
import pickle
import matplotlib.pyplot as plt

img_path = "3-min-pytorch/03-파이토치로_구현하는_ANN"

# 오염된 이미지 불러오기
broken_image = torch.FloatTensor( pickle.load(open(img_path + "/broken_image_t.p", "rb"), encoding = "latin1" ) )

# 오염된 이미지 출력하여 확인
plt.imshow(broken_image.view(100, 100))

# weird_function
def weird_function(x, n_iter=5):
    h = x
    filt = torch.tensor([-1./3, 1./3, -1./3])
    for i in range(n_iter):
        zero_tensor = torch.tensor([1.0*0])
        h_l = torch.cat( (zero_tensor, h[:-1]), 0)
        h_r = torch.cat((h[1:], zero_tensor), 0 )
        h = filt[0] * h + filt[2] * h_l + filt[1] * h_r
        if i % 2 == 0:
            h = torch.cat( (h[h.shape[0]//2:],h[:h.shape[0]//2]), 0  )
    return h

# 무작위 텐서를 weird_function 함수에 입력해 얻은 가설 텐서와
# 오염된 이미지 사이의 오차 구하는 함수 구현

def distance_loss(h, broken_image):
    return torch.dist(h, broken_image)

# 오염된 이미지와 크기가 같은 랜덤 텐서 생성하기
random_tensor = torch.randn(100*100, dtype = torch.float)

lr = 0.8

# 1. 오차 함수를 random_tensor로 미분해야하기 때문에 `requires_grad`를 True로 설정한다.
for i in range(20000):
    random_tensor.requires_grad_(True)

    # 2. 랜덤 텐서를 `weird_function()`에 통과시켜 가설을 구하고,
    # `distance_loss()` 함수에 가설과 오염된 이미지를 입력해 오차를 계산한다.
    # 그 후, `loss.backward()` 함수를 호출하여 loss를 random_tensor로 미분한다.

    hypoth = weird_function(random_tensor)
    loss = distance_loss(hypoth, broken_image)
    loss.backward()

    # 3. 직접 경사하강법을 구현하기 위해 torch.no_grad() 함수를 이용해서
    # 자동 기울기 계산 비활성화.

    with torch.no_grad():
        # 4. random_tensor.grad 에는 loss.backward() 함수에서 계산한 loss 의 기울기가 들어있음.
        # 이 방향의 반대쪽으로 random_tensor를 학습률(lr)만큼 이동.
        random_tensor = random_tensor - lr * random_tensor.grad

    # 반복문 1000번 마다 오차 출력
    if i % 1000 == 0:
        print(f"loss at {i} = {loss.item()}")

# random_tensor 가 제대로 복원되었는지 확인
plt.imshow(random_tensor.view(100, 100).data)