pytorch-1 기본 문법

1. pytorch

파이토치는 딥러닝을 위한 프레임워크로 다른 프레임워크들에 비해서 GPU를 이용한 연산이 가능하고 계산 속도가 빠르다는 장점이 있다.

 

2. 텐서

텐서(tensor)는 배열(array)이나 행렬(matrix)과 매우 유사한 자료구조이다.

텐서는 GPU나 다른 하드웨어 가속기에서 실행할 수 있다는 점만 제외하면 넘파이와 유사하다. 실제로 텐서와 넘파이는 텐서와 동일한 내부 메모리를 공유하기 때문에 데이터를 복사할 필요가 없다.

import torch
import numpy as np

data = [[1,2], [3,4]]
print(type(data))
x_data = torch.tensor(data)

print(x_data)

np_array = np.array(data)
x_np = torch.from_numpy(np_array)
print(x_np)

<class 'list'>
<class 'torch.Tensor'>
tensor([[1, 2],
        [3, 4]], dtype=torch.int32)

배열을 생성하고 torch.tensor에 넣으면 텐서로 변경한다. from_numpy로 넘파이에서 텐서로 변경할 수 있다.

x_ones = torch.ones_like(x_data) 
print(f"ones Tensor : \n{x_ones}")


x_rand = torch.rand_like(x_data, dtype=torch.float) 
print(f'Random Tensor : \n{x_rand}')

ones Tensor : 
tensor([[1, 1],
        [1, 1]])
Random Tensor : 
tensor([[0.8641, 0.8555],
        [0.8338, 0.2406]])

ones 함수는 주어진 사이즈를 1로 채우며 ones_like 함수는 인풋과 동일한 형태로 1을 채울 수 있다.  rand_like는 인풋과 동일한 배열을 0과 1 사이의 랜덤값으로 채운다. 

tensor_val = torch.rand(3,4)

device = 'cuda' if torch.cuda.is_available():
	tensor = tensor.to('cuda')

	else 'cpu'
print(device)

cpu

기본적으로 텐서는 cpu에 생성된다. gpu가 존재하면 텐서를 쿠다로 이동시킬 수 있으나 장치들 간에 큰 텐서를 복사하는 것은 시간과 메모리를 많이 차지할 수 있다.

t = torch.ones(5)
print(t)
n = t.numpy()
print(n)

t.add_(1)
print(t)
print(n)

tensor([1., 1., 1., 1., 1.])
[1. 1. 1. 1. 1.]
tensor([2., 2., 2., 2., 2.])
[2. 2. 2. 2. 2.]

텐서와 넘파이가 메모리를 공유하는 것을 확인할 수 있다.

3. 텐서 슬라이싱, 인덱싱, 결합

tensor_l = torch.ones(4,4)
tensor_l[:,3] = 0

tensor_2 = torch.ones(4,4)
tensor_2[:,1] = 2
print(tensor_l)
print(tensor_2)

tensor([[1., 1., 1., 0.],
        [1., 1., 1., 0.],
        [1., 1., 1., 0.],
        [1., 1., 1., 0.]])
tensor([[1., 2., 1., 1.],
        [1., 2., 1., 1.],
        [1., 2., 1., 1.],
        [1., 2., 1., 1.]])

텐서를 4*4 배열로 1을 채우고 슬라이싱과 인덱싱 할 수 있다.

t1 = torch.cat([tensor_l, tensor_l], dim=1)
print(t1)

tensor([[1., 1., 1., 0., 1., 1., 1., 0.],
        [1., 1., 1., 0., 1., 1., 1., 0.],
        [1., 1., 1., 0., 1., 1., 1., 0.],
        [1., 1., 1., 0., 1., 1., 1., 0.]])

텐서를 cat 명령어로 결합할 수 있다. cat을 하기 위해서는 텐서의 모양이 같거나 비어있어야 한다. 차원을 지정할 수 있으며 지정하지 않으면 0으로 설정된다. 같은 크기의 텐서를 차원으로 쌓고 싶다면 stack을 사용한다.

4. 텐서 행렬 연산

t_mult = tensor_l.mul(tensor_2)
print(t_mult)

print(tensor_l * tensor_2)

tensor([[1., 2., 1., 0.],
        [1., 2., 1., 0.],
        [1., 2., 1., 0.],
        [1., 2., 1., 0.]])
tensor([[1., 2., 1., 0.],
        [1., 2., 1., 0.],
        [1., 2., 1., 0.],
        [1., 2., 1., 0.]])

행렬 합은 mul 함수를 사용하여 실행할 수 있다.

print(tensor_2.matmul(tensor_2.T))
print(tensor_2 @ tensor_2.T)

tensor([[7., 7., 7., 7.],
        [7., 7., 7., 7.],
        [7., 7., 7., 7.],
        [7., 7., 7., 7.]])
tensor([[7., 7., 7., 7.],
        [7., 7., 7., 7.],
        [7., 7., 7., 7.],
        [7., 7., 7., 7.]])

행렬 곱은 matmul, @으로 실행하며 tensor.T는 텐서행렬의 전치행렬을 반환한다. 

5. 텐서 바꿔치기, 모양 바꾸기

print(f"{tensor} \n")
tensor.add_(5)
print(tensor)

tensor([[1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.],
        [1., 0., 1., 1.]])

tensor([[6., 5., 6., 6.],
        [6., 5., 6., 6.],
        [6., 5., 6., 6.],
        [6., 5., 6., 6.]])

함수에 _ 접미사로 연산결과를 피연산자에 저장하는 바꿔치기 연산을 할 수 있다. 바꿔치기 연산은 피연산자의 기록을 즉시 삭제하여 도함수 계산에 문제를 일으킬 수 있기 때문에 권장되지 않는다.

t_temp = np.array([[[0,1,2], [3,4,5]], [[6,7,8], [9,10,11]]])
ft = torch.FloatTensor(t_temp)
print(ft)
print(ft.shape)

print(ft.view([-1,3])) 
print(ft.view([-1,3]).shape)

tensor([[[ 0.,  1.,  2.],
         [ 3.,  4.,  5.]],

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

view 함수는 텐서의 모양을 바꿀 수 있다. -1은 자동으로 값을 설정하고  2*2*3의 텐서가 4*3의 텐서로 바뀌었다.

ft = torch.FloatTensor(([0], [1], [2]))
print(ft)
print(ft.shape)

tensor([[0.],
        [1.],
        [2.]])
torch.Size([3, 1])

FloatTensor는 실수형의 텐서를 생성하며 자료타입에 따라 명령어가 달라진다.

6. 텐서 squeeze, unsqueeze

print(ft.squeeze())
print(ft.squeeze().shape)

tensor([0., 1., 2.])
torch.Size([3])

squeeze는 차원이 1인 모든 부분을 제거한다. 원하는 차원을 선택하면 해당 차원만 지울 수 있다.

ft_temp = torch.Tensor([0,1,2])

print(ft_temp.unsqueeze(0))
print(ft_temp.unsqueeze(0).shape)

tensor([[0., 1., 2.]])
torch.Size([1, 3])

unsqueeze는 반대로 1차원을 추가한다. 원하는 차원을 추가해 1차원을 추가할 수 있다.