파이토치 기본 정리(Pytorch Basic)

깔끔하게 정리는 못했지만...

파이토치를 처음 접해보는 분이라면,

아래 코드를 보고 기본적으로 다루는 방법을 연습 하실 수 있을 겁니다!

 

 

In [1]:

import torch

 

In [2]:

print(torch.__version__)
print(torch.cuda.is_available())

1.9.1+cu111
True

 

 

Pytorch Components

1. torch

• 메인 네임스페이스입니다. Tensor 생성, tensor간의 연산 등 다양한 함수가 정의되어 있습니다. Numpy와 유사한 구조를 가집니다.

2. torch.autograd

• 자동 미분을 위한 함수들이 포함되어져 있습니다. 자동 미분의 on,off를 제어하는 콘텍스트 매니저(enable_grad/no_grad)나 자체 미분 가능 함수를 정의할 때 사용하는 기반 클래스인 'Function' 등이 포함되어져 있습니다.

3. torch.nn

• 신경망을 구축하기 위한 다양한 데이터 구조나 레이어 등이 정의되어져 있습니다. 예를 들어 RNN, LSTM과 같은 레이어, ReLU와 같은 활성화 함수, MSELoss와 같은 손실 함수들이 있습니다.

4. torch.optim

• 확률적 경사 하강법(Stochastic Gradient Descent, SGD)를 중심으로 한 파라미터 최적화 알고리즘이 구현되어져 있습니다.

5. torch.utils.data

• SGD의 반복 연산을 실행할 때 사용하는 미니 배치용 유틸리티 함수가 포함되어져 있습니다.

---

 

In [3]:

# 빈 tensor 생성
tensor_empty = torch.empty(size=(3,2))
tensor_zero1 = torch.zeros(size=(3,2))
tensor_zero2 = torch.zeros_like(tensor_empty)

 

In [4]:

print(tensor_empty)

tensor([[8.1275e-44, 7.1466e-44],
        [7.1466e-44, 6.4460e-44],
        [7.0065e-44, 6.7262e-44]])

 

In [5]:

print(tensor_zero1)
print(tensor_zero2)

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

---

 

In [6]:

# 값을 직접 전달하여 tensor 생성
tensor_cpu = torch.tensor([1,2,3,4])
tensor_gpu = torch.tensor([1,2,3,4], device='cuda:0') # gpu에 
tensor_flo = torch.tensor([1,2,3,4], dtype=torch.float64)
print(tensor_cpu)
print(tensor_gpu)
print(tensor_flo)

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

 

In [7]:

# 텐서의 데이터타입 확인
print(tensor_cpu.dtype)
print(tensor_gpu.dtype)
print(tensor_flo.dtype)

torch.int64
torch.int64
torch.float64

 

In [8]:

# 어떤 장치에 tensor가 생성되었는지 확인
print(tensor_cpu.device)
print(tensor_gpu.device) # cuda:0 은 gpu사용
print(tensor_flo.device)

cpu
cuda:0
cpu

---

 

In [9]:

# tensor의 크기, 차원 확인
b = torch.randn(size=(3,3,3))
print(b.size())
print(b.dim())
print('-----------------------')
print(tensor_cpu.size())
print(tensor_cpu.dim())

torch.Size([3, 3, 3])
3
-----------------------
torch.Size([4])
1

 

In [10]:

print(b.shape)

torch.Size([3, 3, 3])

---

 

In [11]:

# 넘파이로 tensor 생성
import numpy as np

 

In [12]:

np_x = np.arange(32).reshape(4,4,2)

 

In [13]:

print(np_x)

[[[ 0  1]
  [ 2  3]
  [ 4  5]
  [ 6  7]]

 [[ 8  9]
  [10 11]
  [12 13]
  [14 15]]

 [[16 17]
  [18 19]
  [20 21]
  [22 23]]

 [[24 25]
  [26 27]
  [28 29]
  [30 31]]]

 

In [14]:

torch_x = torch.tensor(np_x)

 

In [15]:

print(torch_x)

tensor([[[ 0,  1],
         [ 2,  3],
         [ 4,  5],
         [ 6,  7]],

        [[ 8,  9],
         [10, 11],
         [12, 13],
         [14, 15]],

        [[16, 17],
         [18, 19],
         [20, 21],
         [22, 23]],

        [[24, 25],
         [26, 27],
         [28, 29],
         [30, 31]]], dtype=torch.int32)

---

In [16]:

# 인덱싱
print(torch_x[0])
print(torch_x[1])
print(torch_x[1,0])
print(torch_x[1,0,0])

tensor([[0, 1],
        [2, 3],
        [4, 5],
        [6, 7]], dtype=torch.int32)
tensor([[ 8,  9],
        [10, 11],
        [12, 13],
        [14, 15]], dtype=torch.int32)
tensor([8, 9], dtype=torch.int32)
tensor(8, dtype=torch.int32)

---

 

In [17]:

#Broadcasting
a = torch.tensor([[1,1,1,1]])
b = torch.tensor([[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]])

 

In [18]:

print(a+b)

tensor([[3, 3, 3, 3],
        [3, 3, 3, 3],
        [3, 3, 3, 3],
        [3, 3, 3, 3]])

---

 

In [19]:

# 행렬곱
# 1*2 + 1*2 + 1*2 + 1*2 = 8
torch.matmul(a,b)

tensor([[8, 8, 8, 8]])

 

In [20]:

# 원소간의 곱
torch.mul(a, b)

tensor([[2, 2, 2, 2],
        [2, 2, 2, 2],
        [2, 2, 2, 2],
        [2, 2, 2, 2]])

 

In [21]:

a = torch.randn(size=(3,4,5))
a

tensor([[[ 1.2560, -0.0742, -0.2358,  0.2535,  0.0303],
         [-0.9521,  0.4020,  0.7963, -0.4301, -1.3356],
         [ 1.7780,  0.5246,  0.5085, -1.4925,  0.9328],
         [ 0.7558,  1.7817,  0.6535, -1.1937, -0.5990]],

        [[-0.0928, -0.9312, -1.1898,  0.1251, -2.5063],
         [ 0.0795, -0.2920,  0.7914,  0.6898, -0.8566],
         [-0.4063, -0.4750, -0.1594,  1.0569,  1.1128],
         [ 1.6156,  0.9174, -1.9552,  0.7756,  0.3969]],

        [[ 0.9211,  1.5317, -1.0019,  3.3254,  0.9527],
         [ 0.9054, -0.2068,  0.0715, -0.2406,  1.1702],
         [ 0.3547, -1.0501,  0.1145,  0.3176,  0.4581],
         [ 0.4895, -0.3044, -0.1503,  0.1363, -0.0607]]])

 

In [22]:

# (1.260-0.0928+0.9211)/3
torch.mean(a, dim=0)

tensor([[ 0.6948,  0.1754, -0.8092,  1.2347, -0.5077],
        [ 0.0109, -0.0323,  0.5531,  0.0064, -0.3407],
        [ 0.5754, -0.3335,  0.1545, -0.0393,  0.8346],
        [ 0.9536,  0.7982, -0.4840, -0.0940, -0.0876]])

 

In [23]:

#(1.2560-0.9521+ 1.7780+ 0.7558)/4
torch.mean(a, dim=1)

tensor([[ 0.7094,  0.6585,  0.4306, -0.7157, -0.2429],
        [ 0.2990, -0.1952, -0.6282,  0.6618, -0.4633],
        [ 0.6677, -0.0074, -0.2415,  0.8847,  0.6301]])

 

In [24]:

#1.2560, -0.0742, -0.2358,  0.2535,  0.0303의 평균
torch.mean(a, dim=2)

tensor([[ 0.2460, -0.3039,  0.4503,  0.2797],
        [-0.9190,  0.0824,  0.2258,  0.3501],
        [ 1.1458,  0.3399,  0.0390,  0.0221]])

---

 

In [25]:

a=torch.tensor(np.arange(32).reshape(4,4,2))
a

 

tensor([[[ 0,  1],
         [ 2,  3],
         [ 4,  5],
         [ 6,  7]],

        [[ 8,  9],
         [10, 11],
         [12, 13],
         [14, 15]],

        [[16, 17],
         [18, 19],
         [20, 21],
         [22, 23]],

        [[24, 25],
         [26, 27],
         [28, 29],
         [30, 31]]], dtype=torch.int32)

 

In [26]:

print(torch.max(a))
print(torch.max(a, dim=0)) #인덱스 값도 추출된다.

tensor(31, dtype=torch.int32)
torch.return_types.max(
values=tensor([[24, 25],
        [26, 27],
        [28, 29],
        [30, 31]], dtype=torch.int32),
indices=tensor([[3, 3],
        [3, 3],
        [3, 3],
        [3, 3]]))

---

 

In [27]:

#모양 변경
torch.reshape(a, (8,4))

 

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23],
        [24, 25, 26, 27],
        [28, 29, 30, 31]], dtype=torch.int32)

 

In [28]:

a.view(8,4)

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23],
        [24, 25, 26, 27],
        [28, 29, 30, 31]], dtype=torch.int32)

 

In [29]:

a = torch.tensor(np.arange(32).reshape(4,4,1,1,2))
a

tensor([[[[[ 0,  1]]],


         [[[ 2,  3]]],


         [[[ 4,  5]]],


         [[[ 6,  7]]]],



        [[[[ 8,  9]]],


         [[[10, 11]]],


         [[[12, 13]]],


         [[[14, 15]]]],



        [[[[16, 17]]],


         [[[18, 19]]],


         [[[20, 21]]],


         [[[22, 23]]]],



        [[[[24, 25]]],


         [[[26, 27]]],


         [[[28, 29]]],


         [[[30, 31]]]]], dtype=torch.int32)

 

In [30]:

# 크기가 1인 차원을 제거
a.squeeze().size()

torch.Size([4, 4, 2])

 

In [31]:

a = torch.tensor(np.arange(32).reshape(8,4))
print(a)
print(a.size()) # shape을 써도 된다

tensor([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11],
        [12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23],
        [24, 25, 26, 27],
        [28, 29, 30, 31]], dtype=torch.int32)
torch.Size([8, 4])

 

In [32]:

b = torch.unsqueeze(a, dim=0)
print(b.size())
c = torch.unsqueeze(a, dim=1)
print(c.size())
d = torch.unsqueeze(a, dim=2)
print(d.size())

torch.Size([1, 8, 4])
torch.Size([8, 1, 4])
torch.Size([8, 4, 1])

---

 

In [33]:

a = torch.tensor(np.arange(16).reshape(2,2,4))
b = torch.tensor(np.arange(16,32).reshape(2,2,4))
print(a)
print('-------------------------------------------------')
print(b)

tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7]],

        [[ 8,  9, 10, 11],
         [12, 13, 14, 15]]], dtype=torch.int32)
-------------------------------------------------
tensor([[[16, 17, 18, 19],
         [20, 21, 22, 23]],

        [[24, 25, 26, 27],
         [28, 29, 30, 31]]], dtype=torch.int32)

 

In [34]:

# cat() 두 tensor를 연결해준다.
c = torch.cat((a,b), dim=0)
print(c)
print(c.size())

tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7]],

        [[ 8,  9, 10, 11],
         [12, 13, 14, 15]],

        [[16, 17, 18, 19],
         [20, 21, 22, 23]],

        [[24, 25, 26, 27],
         [28, 29, 30, 31]]], dtype=torch.int32)
torch.Size([4, 2, 4])

 

In [35]:

d = torch.cat((a,b), dim=1)
print(d)
print(d.size())

tensor([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [16, 17, 18, 19],
         [20, 21, 22, 23]],

        [[ 8,  9, 10, 11],
         [12, 13, 14, 15],
         [24, 25, 26, 27],
         [28, 29, 30, 31]]], dtype=torch.int32)
torch.Size([2, 4, 4])

 

In [36]:

e = torch.cat((a,b), dim=2)
print(e)
print(e.size())

tensor([[[ 0,  1,  2,  3, 16, 17, 18, 19],
         [ 4,  5,  6,  7, 20, 21, 22, 23]],

        [[ 8,  9, 10, 11, 24, 25, 26, 27],
         [12, 13, 14, 15, 28, 29, 30, 31]]], dtype=torch.int32)
torch.Size([2, 2, 8])