PyTorch 🫨

PyTorch 개요

1️⃣ 특징 및 장점

특징

GPU에서 텐서 조작 및 동적 신경망 구축이 가능한 프레임워크

▶︎ GPU : 연산 속도를 빠르게 하는 역할

• 딥러닝에서는 기울기를 계산할 때 미분을 쓴는데, GPU를 사용하면 빠른 계산이 가능하다.
• CUDA,cuDNN이라는 API를 통해 GPU를 사용할 수 있다.
• 특히 병렬 계산시 CPU 속도보다 훨씬 빠름 👉🏻 딥러닝에서 GPU사용 필수!

▶︎ 텐서(tensor)

• 파이토치에서 데이터 형태
• 단일 데이터 형식으로 된 자료들의 다차원 행렬 👉🏻 numpy와 유사하다
• 변수 뒤에 .cuda()를 추가함으로써 GPU로 연산을 수행할 수 있다.

import torch
torch.tensor([[1., -1.],[1., -1.]])
#----------------------------------#

# 출력값
tensor([[1., -1.],
		[1., -1.]])

▶︎ 동적 신경망: 훈련을 반복할 때마다 네트워크 변경이 가능한 신경망을 의미

• 연산 그래프를 정의하는 것과 동시에 값도 초기화되는 'Define by Run' 방식을 사용
• 연산 그래프와 연산을 분리해서 생각할 필요가 없기 때문에 코드를 이해하기 쉽다.

장점

• 단순하여 효율적인 계산 가능
• 낮은 CPU의 활용으로 학습 및 추론 속도가 빠르고 다루기 쉬움
• 직관적인 인터페이스로 배우기 쉬움

2️⃣ 파이토치의 구조

파이토치 API

사용자가 이해하기 쉬운 API를 제공하여 텐서에 대한 처리와 신경망을 구축하고 훈련할 수 있도록 돕는다.

• torch
• torch.autograd : 자동 미분 패키지
  • 다른 딥러닝 프레임워크와 가장 차별되는 패키지로 미분 계산을 효율적으로 처리한다.
• torch.nn : 신경망 구축 및 훈련 패키지
• torch.multiprocessing : 파이썬 멀티프로세싱 패키지
• torch.utils : DataLoader 및 기타 유틸리티를 제공하는 패키지

파이토치 엔진

Autograd C++, Aten C++, JIT C++, Python API로 구성되어있다.

연산 처리

가장 아래 계층에 속하는 C 또는 CUDA 패키지는 상위의 API에서 할당된 거의 모든 계산을 수행한다.

• 여기에서 제공되는 패키지는 CPU와 GPU를 이용하여 효율적인 데이터 구조, 다차원 텐서에 대한 연산을 처리한다.

PyTorch 기초 문법

1️⃣ tensor

텐서 생성 및 변환

▶︎ 텐서 생성

import torch
print(torch.tensor([[1,2],[3,4]])) # 2차원 형태의 텐서 생성
print(torch.tensor([[1,2],[3,4]], device="cuda:0")) # GPU에 텐서 생성
print(torch.tensor([[1,2],[3,4]], dtype=torch.float64))

# 출력
tensor([[1, 2],
        [3, 4]])
------------------------
tensor([[1, 2],
        [3, 4]], device='cuda:0')
------------------------
tensor([[1., 2.],
        [3., 4.]], dtype=torch.float64)

▶︎ 텐서 ndarray로 변환

temp = torch.tensor([[1,2],[3,4]])
print(temp.numpy())
temp = torch.tensor([[1,2],[3,4]], device="cuda:0") 
print(temp.to("cpu").numpy()) # GPU상의 텐서를 CPU의 텐서로 변환 후 ndarray로 변환

# 출력
[[1 2]
 [3 4]]
------------------------
[[1 2]
 [3 4]]

텐서 인덱스 조작

▶︎ 텐서의 자료형

• torch.FloatTensor
• torch.DoubleTensor
• torch.LongTensor

▶︎ 인덱싱

temp = torch.FloatTensor([1, 2, 3, 4, 5, 6, 7])
print(temp[0], temp[1], temp[-1]) # 인덱스로 접근
print(temp[2:5], temp[4:-1]) # 슬라이스로 접근

# 출력
tensor(1.) tensor(2.) tensor(7.)
tensor([3., 4., 5.]) tensor([5., 6.])

텐서 연산 및 차원 조작

▶︎ 연산
넘파이의 ndarray처럼 다양한 수학 연산이 가능하며, 텐서 간의 타입이 같을 때 연산이 가능하다.

▶︎ 차원

• 차원 변경 : view
• 차원 결합 : stack, cat
• 차원 교환 : t,transpose

temp = torch.tensor([
    [1, 2], [3, 4]
])

print(temp.shape)
print('------------------------')
print(temp.view(4,1))
print('------------------------')
print(temp.view(-1)) # 1차원 벡터로 변형
print('------------------------')
print(temp.view(1, -1)) # (1,?)과 같은 의미로 다른 차원으로부터 해당 값을 유추하겠다는 의미 
print('------------------------')
print(temp.view(-1, 1)) # (?,1)과 같은 의미로 다른 차원으로부터 해당 값을 유추하겠다는 의미

# 출력
torch.Size([2, 2])
------------------------
tensor([[1],
        [2],
        [3],
        [4]])
------------------------
tensor([1, 2, 3, 4])
------------------------
tensor([[1, 2, 3, 4]])
------------------------
tensor([[1],
        [2],
        [3],
        [4]])

2️⃣ 데이터 준비

데이터가 이미지일 경우 분산된 파일에서 데이터를 읽은 후 전처리를 하고 배치 단위로 분할하여 처리한다.

데이터가 텍스트인 경우 임베딩 과정을 거쳐 서로 다른 길이의 시퀀스를 배치 단위로 분할하여 처리한다.
👉🏻 임베딩이란 사람이 쓰는 자연어를 기계가 이해할 수 있도록 숫자형태인 vector로 바꾸는 과정 혹은 일련의 전체 과정을 뜻한다.

파일 불러오기

JSON, PDF, CSV 등의 파일을 불러오는 방법

import pandas as pd
import torch

data = pd.read_csv('파일 이름.csv')

x = torch.from_numpy(data['x'].values).unsqueeze(dim=1).float()
y = torch.from_numpy(data['y'].values).unsqueeze(dim=1).float()

👉🏻 squeeze 함수는 차원이 1인 차원을 제거해준다. 따로 차원을 설정하지 않는다면 1인 차원을 모두 제거한다. 만약 차원을 설정한다면 그 차원만 제거한다.
👉🏻 unsqueeze 함수는 1인 차원을 생성하는 함수이다. 때문에 어느 차원에 1인 차원을 생성할 지 꼭 지정해주어야한다.
(🔗 출처 : https://sanghyu.tistory.com/86)

커스텀 데이터셋을 만들어서 사용하기

딥러닝에서 대용량 데이터를 한 번에 메모리에 불러와 훈련시키면 시간과 비용 측면에서 효율적이지 않다. 때문에 `커스텀 데이터셋`을 활용해 조금씩 데이터를 나눠 불러 사용한다.

기본형태는 다음과 같다.

class CustomDataset(torch.utils.data.Dataset):
	def __init__(self): # 필요한 변수를 선언하고, 데이터셋의 전처리를 해 주는 함수
    def __len__(self): # 데이터셋의 길이. 즉, 총 샘플의 수를 가져오는 함수
    def __getitem__(self,index): # 데이터셋에서 특정 데이터를 가져오는 함수(index번째 데이터를 반환하는 함수이며, 이때 반환되는 값은 텐서의 형태를 취해야 한다.)
    
tensor_dataset = CustomDataset('파일명')
dataset = DataLoader(tensor_dataset,batch_size=4,shuffle=True)

▶︎ DataLoader

• 데이터셋의 특징을 가져오고 하나의 샘플에 label을 지정하는 일을 한 번에 한다.

• Dataset을 batch기반의 딥러닝모델 학습을 위해서 미니배치 형태로 만들어서 우리가 실제로 학습할 때 이용할 수 있게 형태를 만들어주는 기능을 한다.

  • batch Dataset의 전체 데이터가 batch size로 slice되어 공급된다.(여러 옵션 (데이터 묶기, 섰기, 알아서 병렬처리)을 통해 batch를 만들어 줌) / 각 mini-batch의 크기 즉 한 번의 배치 안에 있는 샘플 사이즈를 말한다.
  • shuffle epoch마다 데이터셋을 섞어, 데이터가 학습되는 순서를 바꾸는 기능으로 학습 할 때는 항상 True로 설정하는 것을 권장한다.
  • num_worker 동시에 처리하는 프로세서의 수로 num_worker 하나를 더 추가하면 20% 정도 속도가 빨라진다.
    

파이토치에서 제공하는 데이터셋 사용

토치비젼은 파이토치에서 제공하는 데이터셋들이 모여 있는 패키지이다. MNIST, ImageNet을 포함한 유명한 데이터셋들을 제공하고 있다.

3️⃣ 모델 정의

단순 신경망을 정의

model = nn.Linear(in_features = 1,out_features = 1, bias=True)

nn.Module()을 상속하여 정의

파이톹치에서 nn.Module을 상속받는 모델은 기본적으로 __init__()과 forward() 함수를 포함한다.

▶︎ init() : 모델에서 사용될 모듈, 활성화 함수 등을 정의
▶︎ forward() : 모델에서 실행되어야 하는 연산을 정의

class MLP(Module):
def __init__(self,inputs):
	super(MLP,self).__init__()
    self.layer = Linear(inputs,1) # 계층 정의
    self.activation = Sigmoid() # 활성화 함수 정의
    
def forward(self,x):
	X = self.layer(x)
    X = self.activation(X)
    return X

Sequential 신경망을 정의

nn.Sequential을 사용하면 좀 더 가독성이 뛰어나게 코드로 작성할 수 있다. 또한, 그 안에 포함된 각 모듈을 순차적으로 실행해 준다.

import torch.nn as nn

model = nn.Sequential(
          nn.Conv2d(1,20,5),
          nn.ReLU(),
          nn.Conv2d(20,64,5),
          nn.ReLU()
        )

nn.Sequential은 모델의 계층이 복잡할수록 효과가 더 뛰어나다!

(🔗 출처 : https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html )

4️⃣ 모델의 파라미터 정의

손실함수

학습하는 동안 출력과 실제 값 사이의 오차를 측정

• BCELoss : 이진 분류를 위해 사용
• CrossEntropyLoss : 다중 클래스 분류를 위해 사용
• MSELoss : 회귀 모델에서 사용

옵티마이저

데이터와 손실 함수를 바탕으로 모델의 업데이트 방법을 결정

▶︎ 옵티마이저의 주요 특성

• step() 메서드를 통해 전달받은 파라미터를 업데이트한다.
• zero_grad() 메서드는 옵티마이저에 사용된 파라미터들의 기울기를 0으로 만들어 준다.
• torch.optim.lr_scheduler : 에포크에 따라 학습률(learning rate)을 조절할 수 있다.

학습률 스케줄러

미리 지정한 횟수의 에포크를 지날 때마다 학습률을 감소시킨다. 학습률 스케줄러를 이용하면 학습 초기에는 빠른 학습을 진행하다가 `전역 최소점` 근처에 다다르면 학습률을 줄여서 최적점을 찾아갈 수 있도록 해준다.

지표

훈련과 테스트 단계를 모니터링한다.

5️⃣ 모델 훈련

앞서 만든 모델을 이용하여 데이터를 학습시킨다. 오차가 줄어들어 전역 최소점에 이를때까지 파라미터를 계속 수정한다.

▶︎ 절차

• optimizer.zero_grad() 메서드를 이용해 기울기를 초기화!(중요!)
  👉🏻 파이토치는 기울기 값을 계산하기 위해 loss.backward() 메서드를 이용하는데, 이것을 사용하면 새로운 기울기 값이 이전 기울 값에 누적되기 때문에 초기화가 필요하다.(단, RNN을 구현할 때는 효과적!)
• loss.backward() 메서드를 이용해 기울기를 자동 계산

for epoch in range(100):
	yhat = model(X_train)
    loss = criterion(yhat,y_train)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

6️⃣ 모델 평가

주어진 테스트 데이터셋을 사용하여 모델을 평가한다.

model.eval()
모델을 평가할 때는 모든 노드를 사용하겠다는 의밀로 검증과 테스트 데이터셋에 사용한다.
🚨 model.eval()에서는 no_grad()를 사용하지 않는다! 검증과정에서는 역전파가 필요하지 않기 때문이다.