-
๋ณธ ๊ธ์ '๋ชจ๋๋ฅผ ์ํ ๋ฅ๋ฌ๋ ์์ฆ 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 torcht = torch.FloatTensor([0., 1.])print(t.dim()) #ํ์ฌ ํ ์์ ์ฐจ์์ ๋ณด์ฌ์คprint(t.shape) #shape (๋๋ค ํฌ๊ธฐ๋ฅผ ํ์ธํ ์ ์์)print(t.size()) #shape1
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()) #Shape2
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 1print(m1 * m2) # 2 x 2print(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