• 01. PyTorch ๊ธฐ์ดˆ

    2020. 2. 13.

    by. ํ•ด๋Š”์„ 

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

     

    '๐Ÿ“š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

    ๋Œ“๊ธ€