๐Ÿ“šSTUDY/๐Ÿ”ฅPytorch ML&DL

01. PyTorch ๊ธฐ์ดˆ

ํ•ด๋Š”์„  2020. 2. 13. 02:39

๋ณธ ๊ธ€์€ '๋ชจ๋‘๋ฅผ ์œ„ํ•œ ๋”ฅ๋Ÿฌ๋‹ ์‹œ์ฆŒ 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

https://wikidocs.net/52460