Torch 튜토리얼

개발환경 설치

 

아나콘다, torch 설치

https://powerofsummary.tistory.com/250?category=879681 

[conda, torch install] 아나콘다 설치, torch 설치 기록

 

torch 사용법

tensor(data)  #data로 tensor 생성
from_numpy(np_arry) # numpy로 tensor 생성
ones_like(tensor) #tensor shape과 같은 entry가 1인 tensor 생성
rand_like(tensor, dtype=torch.float) # entry가 랜덤 
rand(shape) #tuple shape으로 tensor 생성
ones(shape) # 1 tesnsor
zeros(shape) # 0 tensor

Attribute

.shape #torch.size((x,y))
.dtype # float32 등
.device #cpu or cuda

Tensor Operation

GPU 사용방법

tensor.to("cuda") #GPU 없을시 'cpu'로 설정
if args.cpu:
    device = torch.device('cpu')
else:
    device = torch.device('cuda')
    
 x = torch.tensor([1., 2.]).to(device) # 설정된 device에 tensor 할당 
 
출처 : https://y-rok.github.io/pytorch/2020/10/03/pytorch-gpu.html

# tensor를 gpu에 할당하는 3가지 방법 ("cuda" -> default cuda device (default gpu device))

x = torch.tensor([1., 2.], device="cuda") 
x = torch.tensor([1., 2.]).cuda() 
x = torch.tensor([1., 2.]).to("cuda") 

print(x.device) # 할당된 device 정보 -> cuda:0

출처 : https://y-rok.github.io/pytorch/2020/10/03/pytorch-gpu.html

기타 tensor operation

cat([tensor1, tensor2, ...], dim=1) # tensor 합치기
@ #행렬 곱
tensor1.matmul(tensor2)  #행렬 곱
* #원소 곱
tensor1.mul(tensor2)  #원소 곱
sum = tensor.sum() # tensor 원소 합을 담은 tensor를 반환
sum_item = sum.item() # .item()으로 값 출력, element가 1개일때만 item()으로 반환가능
print(sum_item) # 12.0 값 출력
_ #inplace 연산자 // add_ // copy_ // t_

torch 라이브러리

torch.utils.data.Dataset #sample과 label을 저장

torch.utils.data.DataLoader # dataset을 iterable 객체로 변환

target_transform으로 one-hot-encoding 적용

training_data = datasets.FashionMNIST(
    root="data",  
    train=True,
    download=True,  			#download=True // root경로에 data 없을시 다운로드
    transform=ToTensor(),		#transform = ToTensor() // tensor로 변형
    target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(0, torch.tensor(y), value=1))
						#target label에 obe-hot-encoding 
                        #scatter_(dim,index_tensor,value)
)
test_data = datasets.FashionMNIST(root="data", train=False, download=True, transform=ToTensor())

train_dataloader = DataLoader(training_data, batch_size=64, shuffle=True)
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)

enumerate(dataloader)로 batch 전달

def train_loop(dataloader, model, loss_fn, optimizer):
  size = len(dataloader.dataset)
  for batch, (X,y) in enumerate(dataloader): #dataloader 로 batch 전달
    pred = model(X)
    loss = loss_fn(pred, y)

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

Model layer를  Class로 정의

class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.flatten = nn.Flatten()				#2D-image -> 1D array 변환
        self.linear_relu_stack = nn.Sequential( #sequential container로 신경망 설계
            nn.Linear(28*28, 512),    			#layer1
            nn.ReLU(),							#layer2
            nn.Linear(512, 512),				#layer3
            nn.ReLU(),							#layer4
            nn.Linear(512, 10),					#layer5
        )

    def forward(self, x):
        x = self.flatten(x)
        logits = self.linear_relu_stack(x)
        return logits

torch.autograd

weight와 bias 생성시 grad 속성 추가, loss.backward()로 자동 grad 

weight = tensor.rand(n1,n2, requires_grad=True) # auto-grad 기능 사용
weight.requires_grad(True) # 생성 이후에 추가할때 사용
loss.backward()로 grad 자동 계산 #backward는 한번만 계산하며, 여러번 할때는 retain_graph=True 사용

with no_grad() : requires_grad = False 로 grad disable  #frozen parameter 사용시, backward를 사용하지 않을때

with torch.no_grad():
    z = torch.matmul(x, w)+b
print(z_det.requires_grad) # False
z = torch.matmul(x, w)+b
z_det = z.detach()
print(z_det.requires_grad) # False

Optimizer

torch.optim.xxx

optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

optimizer.zero_grad() 		#parameter들의 grad값 reset
loss.backward()			#grad 계산
optimizer.step()		#parameter에 grad값 적용

model 저장/불러오기

weight 

 

model = models.vgg16() 		#가중치를 불러오지 않으므로 pretrained=True 생략
model = models.vgg16(pretrained=True)		#True = 가중치 불러오기//models.vgg16() = architecture만 로드
torch.save(model.state_dict(), 'model_weights.pth')		#기본 저장
torch.save(model.state_dict(), 'model_name{}.pth'.format(epoch))		#epoch별 저장

model.load_state_dict(torch.load(path + 'model_weights.pth'))
model.eval()		#dropout과 batch normalization 을 disable 하는 기능
			참조 : https://yuevelyne.tistory.com/10

architecture

torch.save(model, 'model.pth')		#기본 저장
model = torch.load('model.pth')		#기본 로드

전체 구현

def train_loop(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)
    for batch, (X, y) in enumerate(dataloader):		#dataloader 으로 batch 전달
        # 예측(prediction)과 손실(loss) 계산
        pred = model(X)					#model 통과
        loss = loss_fn(pred, y)				#loss 계산

        # 역전파
        optimizer.zero_grad()				#grad reset
        loss.backward()					#grad 계산
        optimizer.step()				#grad 적용

        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")


def test_loop(dataloader, model, loss_fn):
    size = len(dataloader.dataset)
    num_batches = len(dataloader)
    test_loss, correct = 0, 0

    with torch.no_grad():				#test시 backward 미적용
        for X, y in dataloader:
            pred = model(X)
            test_loss += loss_fn(pred, y).item()	#loss 누적
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()

    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")

 

출처 : https://tutorials.pytorch.kr/

파이토치(PyTorch) 한국어 튜토리얼에 오신 것을 환영합니다!