-
๋ณธ ๊ธ์ '๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋ ์์ฆ 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.],
[11.]])tensor([[1., 2.],
[6., 8.]])tensor([[1., 2.],
[6., 8.]])ํ๋ ฌ ๊ณฑ์ ์ (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
'๐STUDY > ๐ฅPytorch ML&DL' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
05. Logistic Regression (0) 2020.02.28 04-2. Loading Data(Mini batch and data load) (0) 2020.02.24 04-1. Multivariable Linear regression (0) 2020.02.24 03. Deeper Look at Gradient Descent (0) 2020.02.24 02. Linear Regression (0) 2020.02.21 ๋๊ธ