파이썬 Pytorch

Heath_Jeong·2021년 3월 7일

python

Ustage Week3 - DL Basic

목록 보기

3/10

PyTorch 시작하기

딥러닝 코드를 처음부터 다 짠다?

죽을 수도 있음;;
현재는 이렇게 하는 경우 거의 없음
스터디용으로는 가능
남이 만든 라이브러리, 프레임워크를 씀
현재는 텐서플로우+케라스 (TF2.0, 사실상 하나로 나옴, 구글 진영) or 파이토치 (페이스북 진영) 사용
텐서플로우 - 하이레벨 (인간친화적), 세션 (공간) 을 마련해두고 값을 주입하는 형태 (어려움)
파이토치 - 초기에는 로우레벨, 토치 기반 언어
케라스는 텐서플로우를 쉽게 쓰기 위해 사용
논문 같은데는 파이토치, 실제 서비스할 때는 텐서플로우도 많이 씀

Pytorch

Numpy + AutoGrad + Function
Numpy 구조를 가진 Tensor 객체로 array 표현
자동미분을 지원하여 DL 연산 지원
다양한 형태의 DL 지원 함수와 모델 지원 (새 논문 나올 때마다 새로 생김)
PyTorch 로 시작하는 딥러닝 입문 책 추천

VSCode ssh 사용

VSCode ssh 를 사용하여 colab 의 원격컴퓨팅 환경을 내 컴퓨터의 vscode 에서 작업할 수 있다.
아래 링크 참고

WassimBenzarti/colab-ssh

실행과정

1) colab 에서 내 구글드라이브 마운트, 인증까지 완료할 것

    from google.colab import drive
    drive.mount('/content/drive')

2) cloudflared 실행

    from colab_ssh import launch_ssh_cloudflared, init_git_cloudflared
    launch_ssh_cloudflared(password="cho7611278")

3) vscode 에서 실행

- 커맨트+쉬프트+p → connect to host → [rank-outdoor-rt-rise.trycloudflare.com](http://rank-outdoor-rt-rise.trycloudflare.com/) 실행후 비밀번호 입력

Tips

vscode ssh 로 코랩 접속해서 .py 로 작업하는거 추천
OOP 개념 활용해서 파일들 구분하는거 추천

Pytorch 코드

import torch 하여 임포트
torch.FloatTensor() 에 numpy 의 ndarray 를 넣어 1대1 대응 가능
numpy 의 dot product → matmul 함수
* 연산하면 브로드캐스팅 or elementry-wise 연산 일어남 → mul 함수로도 가능
numpy 의 axis → dim 파라미터
numpy 의 reshape → view 함수
squeeze 함수 : rank 를 1개 줄임
unsqueeze 함수 : rank 를 1개 늘림 (둘 다 dim 파라미터 가능)

Pytorch 의 ML/DL formula

import torch.nn.functional as F
F.softmax(tensor, dim=0)
argmax

    y = torch.randint(5, (10,5))
    print(y)
    '''
    tensor([[2, 4, 2, 4, 4],
            [4, 4, 0, 1, 2],
            [2, 1, 3, 3, 0],
            [4, 3, 1, 3, 0],
            [4, 1, 2, 2, 4],
            [2, 2, 4, 3, 2],
            [1, 0, 0, 4, 4],
            [4, 3, 4, 3, 1],
            [3, 4, 3, 1, 1],
            [1, 2, 2, 3, 1]])
    '''
    y_label = y.argmax(dim=1)
    y_label
    '''
    tensor([1, 0, 2, 4, 0, 0, 0, 4, 2, 2])
    '''

one_hot 함수 사용 가능
autograd 함수 자주 사용

$y = w^2$ ,
$z\ =\ 2\ *\ y\ +\ 5$ ,
$z\ =\ 2\ *\ w^2\ +\ 5$
에서 z 미분 구하기

    w = torch.tensor(2.0, requires_grad=True)
    y = w**2
    z = 2*y + 5

    z.backward()
    w.grad
    '''
    tensor(8.) # z/dw = 4*w -> w = 2 -> 8
    '''

backward 의 파라미터로 gradient 를 설정해줄 수도 있음 → 미분할 때 해당 값만큼 곱함

선형회귀에서 autograd

$y = 2*x+1$

import numpy as np
# create dummy data for training
x_values = [i for i in range(11)]
x_train = np.array(x_values, dtype=np.float32)
x_train = x_train.reshape(-1, 1)

y_values = [2*i + 1 for i in x_values]
y_train = np.array(y_values, dtype=np.float32)
y_train = y_train.reshape(-1, 1)

import torch
from torch.autograd import Variable
class LinearRegression(torch.nn.Module):
    def __init__(self, inputSize, outputSize):
        super(LinearRegression, self).__init__()
        self.linear = torch.nn.Linear(inputSize, outputSize)

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

inputDim = 1        # takes variable 'x' 
outputDim = 1       # takes variable 'y'
learningRate = 0.01 
epochs = 100

model = LinearRegression(inputDim, outputDim)
##### For GPU #######
if torch.cuda.is_available():
    model.cuda()

criterion = torch.nn.MSELoss() 
optimizer = torch.optim.SGD(model.parameters(), lr=learningRate)

for epoch in range(epochs):
    # Converting inputs and labels to Variable
    if torch.cuda.is_available():
        inputs = Variable(torch.from_numpy(x_train).cuda())
        labels = Variable(torch.from_numpy(y_train).cuda())
    else:
        inputs = Variable(torch.from_numpy(x_train))
        labels = Variable(torch.from_numpy(y_train))

    # Clear gradient buffers because we don't want any gradient from previous epoch to carry forward, dont want to cummulate gradients
    optimizer.zero_grad()

    # get output from the model, given the inputs
    outputs = model(inputs)

    # get loss for the predicted output
    loss = criterion(outputs, labels)
    print(loss)
    # get gradients w.r.t to parameters
    loss.backward()

    # update parameters
    optimizer.step()

    print('epoch {}, loss {}'.format(epoch, loss.item()))

'''
...
epoch 98, loss 0.19512228667736053
tensor(0.1929, device='cuda:0', grad_fn=<MseLossBackward>)
epoch 99, loss 0.1929432600736618
'''

with torch.no_grad(): # we don't need gradients in the testing phase
    if torch.cuda.is_available():
        predicted = model(Variable(torch.from_numpy(x_train).cuda())).cpu().data.numpy()
    else:
        predicted = model(Variable(torch.from_numpy(x_train))).data.numpy()
    print(predicted)

'''
[[ 0.1829003]
 [ 2.3005698]
 [ 4.4182396]
 [ 6.535909 ]
 [ 8.653579 ]
 [10.771248 ]
 [12.888918 ]
 [15.006587 ]
 [17.124256 ]
 [19.241926 ]
 [21.359596 ]]
'''