01. PyTorch ๊ธฐ์ด
๋ณธ ๊ธ์ '๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋ ์์ฆ 2'์ 'pytorch๋ก ์์ํ๋ ๋ฅ ๋ฌ๋ ์ ๋ฌธ'์ ๋ณด๋ฉฐ ๊ณต๋ถํ ๋ด์ฉ์ ์ ๋ฆฌํ ๊ธ์ ๋๋ค.
ํ์์ ์๊ฒฌ์ด ์์ฌ ๋ค์ด๊ฐ ๋ถ์ ํํ ๋ด์ฉ์ด ์กด์ฌํ ์ ์์ต๋๋ค.
01. pytorch pagkage ๊ธฐ๋ณธ ๊ตฌ์ฑ
torch : ๋ฉ์ธ ๋ค์์คํ์ด์ค
torch.autograd : ์๋ ๋ฏธ๋ถ์ ์ํ ํจ์๋ค(function)
torch.nn : ์ ๊ฒฝ๋ง ๊ตฌ์ถ์ ์ํ ๋ค์ํ ๋ฐ์ดํฐ ๊ตฌ์กฐ & ๋ ์ด์ด
torch.optim : ์ต์ ํ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ
torch.utils.data : SGD์ ๋ฐ๋ณต์ฐ์ฐ์ ์คํํ ๋ ์ฌ์ฉํ๋ ๋ฏธ๋ ๋ฐฐ์น์ฉ ์ ํธ๋ฆฌํฐ ํจ์
torch.onnx : ONNX์ ํฌ๋งท.
02. Vector, Matrix, and Tensor
1์ฐจ์ (1D) - vector
2์ฐจ์ (2D) - matrix
3์ฐจ์ (3D) - Tensor
⇒ ๋งค ์ฐ์ฐ๋ง๋ค ๋งคํธ๋ฆญ์ค์ ํฌ๊ธฐ๋ฅผ ์๊ณ ์์ด์ผ ํ๋ค.
2D Tensor ⇒ |t| = (batch size, dim)
3D Tensor ⇒ |t| = (batch size, width, height)
03. Pytorch Tensor Allocation
1) 1D
import torch
t = torch.FloatTensor([0., 1.])
print(t.dim()) #ํ์ฌ ํ
์์ ์ฐจ์์ ๋ณด์ฌ์ค
print(t.shape) #shape (๋๋ค ํฌ๊ธฐ๋ฅผ ํ์ธํ ์ ์์)
print(t.size()) #shape
1 torch.Size([2]) torch.Size([2]) |
์ธ๋ฑ์ค๋ก ์ ๊ทผํ๋ ๊ฒ๊ณผ ์ฌ๋ผ์ด์ฑ์ Numpy์ ๋์ผํ๋ค.
2) 2D
t = torch.FloatTensor([[1., 2., 3.],
[4., 5., 6.],
[7., 8., 9.],
[10., 11., 12.]
])
print(t.dim()) #์ฐจ์์ ๋ณด์ฌ์ค
print(t.size()) #Shape
2 torch.Size([4, 3]) |
2์ฐจ์์ด๋ผ ์ฌ๋ผ์ด์ฑ์ ํ ๋, ํ๊ฐ์ ์ผํ(,)๊ฐ ๋ค์ด๊ฐ์ผํ๋ค.
print(t[:, 1]) # ์ฒซ๋ฒ์งธ ์ฐจ์์ ์ ์ฒด ์ ํํ ์ํฉ์์ ๋๋ฒ์งธ ์ฐจ์์ ์ฒซ๋ฒ์งธ ๊ฒ๋ง ๊ฐ์ ธ์จ๋ค.
print(t[:, 1].size()) # ↑ ์์ ๊ฒฝ์ฐ์ ํฌ๊ธฐ
tensor([ 2., 5., 8., 11.]) torch.Size([4]) |
์ฝ๊ฐ ๊ฐ๋ก ์ธ๋ก๊ฐ์ ๋๋? ์ธ๋ก ์ ์ฒด๋ฅผ ์ ํํ๊ณ , ๊ฐ๋ก์์ ์ฒซ๋ฒ์งธ ๊ฒ(์ค)๋ง ๊ฐ์ ธ์จ๋ค๊ณ ์๊ฐํด๋ ๋ ๊ฒ ๊ฐ๋ค.
3) Broadcasting
์๋์ผ๋ก ํฌ๊ธฐ๋ฅผ ๋ง์ถฐ์ ์ฐ์ฐ์ ์ํํ๊ฒ ๋ง๋๋ ๊ธฐ๋ฅ์ด๋ค. ํฌ๊ธฐ๊ฐ ๋ค๋ฅธ ํ ์๋ค๊ฐ์ ์ฐ์ฐ์์, ๋ธ๋ก๋ ์บ์คํ ์ ํตํด ๊ฐ ํ ์์ ํฌ๊ธฐ๋ฅผ ๋ง์ถฐ์ค๋ค.
๋งค์ฐ ํธ๋ฆฌํ ๊ธฐ๋ฅ์ด์ง๋ง, ์๋์ผ๋ก ์คํ๋๋ ๊ธฐ๋ฅ์ด๋ผ ๋งค์ฐ ์ฃผ์ํด์ ์ฌ์ฉํด์ผ ํ๋ค! ๋ ํ ์์ ํฌ๊ธฐ๊ฐ ๊ฐ๋ค๊ณ ์ฐฉ๊ฐํด์ ์ฐ์ฐ์ ํ๋ค๋ฉด, ๋์ค์ ์๊ธฐ๋ ์ค๋ฅ๋ฅผ ์ฐพ์๋ด๊ธฐ๊ฐ ๋งค์ฐ ํ๋ค๋ค.
4) Matrix Multiplication Vs. Multiplication
ํ๋ ฌ ๊ณฑ์ vs. ์์๋ณ ๊ณฑ์
m1 = torch.FloatTensor([[1, 2], [3, 4]])
m2 = torch.FloatTensor([[1], [2]])
print(m1.matmul(m2)) # 2 x 1
print(m1 * m2) # 2 x 2
print(m1.mul(m2))
tensor([[ 5.], tensor([[1., 2.], tensor([[1., 2.], |
ํ๋ ฌ ๊ณฑ์ ์ (m*n) x (n*k) = (m*k) ํ์์ผ๋ก ๋์ค๋ ๊ณฑ์ ์ด๊ณ matmul์ ์ด์ฉํ๋ค.
์์๋ณ ๊ณฑ์ ์ ๊ทธ ์๋ฆฌ์ ์๋ ์์๋ผ๋ฆฌ ๊ณฑํ๋ ๋ฐฉ์์ผ๋ก, ๊ธฐํธ * ์ ์ฌ์ฉํ๊ฑฐ๋ mul์ ์ฌ์ฉํ๋ค.
a.matmul(b) == a · b ≠ a*b == a.mul(b)
5) etc...
- dim = ์ง์ → ์ด์ด ๊ธฐ์ค
dim = ํ์ → ํ์ด ๊ธฐ์ค
- mean
ํ๊ท ๊ตฌํ ๋ ์ฌ์ฉ. ์ฐจ์์ ์ธ์๋ก ์ค ์ ์๋ค.
์ฐจ์์ ์ธ์๋ก ์ค๋ค = ํด๋น ์ฐจ์์ ์ ๊ฑฐํ๋ค.
t = torch.FloatTensor([[1, 2], [3, 4]])
print(t.mean())
print(t.mean(dim=0))
print(t.mean(dim=1))
tensor(2.5000) tensor([4., 6.]) tensor([1.5000, 3.5000]) |
- sum
ํฉ์ ๊ตฌํ ๋ ์ฌ์ฉ. ์ฐจ์์ ์ธ์๋ก ์ค ์ ์๋ค.
mean๊ณผ dim์ ์ฌ์ฉ๋ฐฉ๋ฒ์ ๊ฐ๋ค.
print(t.sum()) # ๋จ์ํ ์์ ์ ์ฒด์ ๋ง์
์ ์ํ
print(t.sum(dim=0)) # ํ์ ์ ๊ฑฐ
print(t.sum(dim=1)) # ์ด์ ์ ๊ฑฐ
print(t.sum(dim=-1)) # ์ด์ ์ ๊ฑฐ
tensor(10.) tensor([4., 6.]) tensor([3., 7.]) tensor([3., 7.]) |
- max & argmax
max๋ ์ต๋๊ฐ์ ๋ฆฌํดํ๋ค. argmax๋ max์ index๋ฅผ ๋ฆฌํดํ๋ค.
max์ dim์ธ์๋ฅผ ์ฃผ๋ฉด argmax๋ ํจ๊ป ๋ฆฌํดํ๋ค.
- view โ
์์์ ์๋ฅผ ์ ์งํ๋ฉด์ ํ ์์ ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ๋ค! ( = reshape)
view์์ ์ ๊ณฑ์ด ์๋์ ํ ์ ์ ๊ณฑ๊ณผ ์ผ์นํด์ผ ํ๋ค.(์์์ ์๋ ์ ์ง๋์ด์ผ ํ๋๊น!)
์ฌ์ด์ฆ๋ฅผ ๋ณ๊ฒฝํ ๋, -1๋ก ์ค์ ๋์ด ์๋ค๋ฉด ๋ค๋ฅธ ์ฐจ์์ผ๋ก ๋ถํฐ ํด๋น ๊ฐ์ ์ ์ถํ๋ค.(๋ฐฉ์ ์์ ๋ง์ถ๋ ๊ฒ ์ฒ๋ผ)
ํฌ๊ธฐ๊ฐ [2, 2, 3] ์ธ ํ ์ ft๊ฐ ์๋ค๊ณ ์น ๋, ft.view([-1, 3])๋ฅผ ์ฌ์ฉํ๋ฉด ํฌ๊ธฐ๊ฐ [4, 3]์ธ ํ ์๋ฅผ ๋ง๋ ๋ค.
- squeeze
์ฐจ์์ ์ค์ธ๋ค. ๊ทธ๋ฐ๋ฐ ์ค์ผ ์ฐจ์์ ๊ฐ์ด 1์ผ๋๋ง ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค. (์๋๋๋ ์๋ฌด ํจ๊ณผ ์์)
์ฆ, ๊ทธ ์ฐจ์ ์์ ๊ฐ์ด ํ๋์ฌ์ ([[1]] ๊ฐ์ ๊ฒฝ์ฐ), ๊ตณ์ด ์ฐจ์์ ๊ฐ์ง ํ์๊ฐ ์์ ๋ ์ฌ์ฉ.
dim์ ์์๋ก ์ค ์ ์๋ค.
- unsqueeze
์์ ๋ฐ๋. ์ฐจ์์ ๋๋ ค์ค๋ค.
์ด ๋๋ dim์ด ํ์ ์์๋ค. ์ด๋ ์ฐจ์์ ๋๋ ค์ค๊ฑด์ง ์์์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
- type casting
ํ ์์ ํ์ ์ ๋ฐ๊ฟ์ค๋ค.
์ด๋ฆ.ํ ์์ํ์ ( )
- concatenate
์ด์ด๋ถ์ด๊ธฐ. dim์ ์์๋ก ์ค ์ ์๋ค.
0์ด๋ฉด ์๋(์ฒซ๋ฒ์งธ ์ฐจ์์ ๋๋ ค๋ผ)๋ก, 1์ด๋ฉด ์ค๋ฅธ์ชฝ์ผ๋ก ๋ถ์ธ๋ค.
torch.cat([a, b], dim=0)
- stacking
์คํ์ฒ๋ผ ์์์ค๋ค.
torch.stack([a, b, c], (dim=0))
๊ธฐ๋ณธ์ด dim = 0, ์๋๋ก ์๊ธฐ๋ค. 1๋ก ์ง์ ํ๋ฉด ์์ผ๋ก ์๋๋ค.
torch.cat([a.unsqueeze(0), b.unsqueeze(0), c.unsqueeze(0)], dim=0)
์ ์๊ณผ ๋์ผํ ๋ป์ด๋ค.
- Ones and Zeros
0 or 1 ๋ก๋ง ์ฑ์ด๋ค.
torch.ones(size)
torch.zeros(size)
torch.ones_like(x)
torch.zeros_like(x)
์์ ๋๊ฐ๋ ์ฌ์ด์ฆ๋ฅผ ํํ๋ก ์ ๋ ฅํ ๋, ์๋ ๋๊ฐ๋ ์ฌ์ด์ฆ๋ฅผ ๊ธฐ์กด์ ํ ์๋ก ๋๊ฒจ์ค ๋ ์ฌ์ฉํ๋ค.
- In-place Operation
๊ธฐ์กด์ ํ ์์ ์ฐ์ฐ์ ํ ๋ค, ๋ฎ์ด์ด๋ค.
์ฐ์ฐ ๋ค์ _๋ฅผ ๋ถ์ด๋ฉด ๋๋ค.
- scatter
scatter(dim, index, src|val)
<Reference>
https://deeplearningzerotoall.github.io/season2/lec_pytorch.html