๐ ๊ณต๋ถ ์ฐธ๊ณ ์๋ฃ : https://wikidocs.net/book/2788
๐ ์ฝ๋ฉ ์ค์ต
https://colab.research.google.com/drive/11uzhksM-MYSf1_YcMzrOnEL6glhu1OiL?usp=sharing
โ ํ์ดํ ์น ๊ธฐ์ด
1๏ธโฃ ํ์ดํ ์น ํจํค์ง ๊ธฐ๋ณธ ๊ตฌ์ฑ
โ torch : ๋ํ์ด์ ์ ์ฌํ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ฉฐ ๋ค์ํ ์ํ ํจ์๊ฐ ํฌํจ๋์ด ์๋ค.
โ torch.autograd : ์๋ ๋ฏธ๋ถ์ ์ํ ํจ์๋ค์ด ํฌํจ๋์ด์ ธ ์๋ค.
โ torch.nn : ์ ๊ฒฝ๋ง์ ๊ตฌ์ถํ๊ธฐ ์ํ ๋ค์ํ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ ๋ ์ด์ด ๋ฑ์ด ์ ์๋์ด์ ธ ์๋ค. RNN, LSTM ๊ฐ์ ๋ ์ด์ด, ReLU ๊ฐ์ ํ์ฑํ ํจ์, MSELoss ๊ฐ์ ์์คํจ์๋ค์ด ์๋ค.
โ torch.optim: ํ๋ฅ ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ SGD ๋ฅผ ์ค์ฌ์ผ๋ก ํ ํ๋ผ๋ฏธํฐ ์ต์ ํ ์๊ณ ๋ฆฌ์ฆ์ด ๊ตฌํ๋์ด์ ธ ์๋ค.
โ torch.utils.data : SGD ๋ฐ๋ณต ์ฐ์ฐ์ ์คํํ ๋ ์ฌ์ฉํ๋ ๋ฏธ๋๋ฐฐ์น์ฉ ์ ํธ๋ฆฌํฐ ํจ์๊ฐ ํฌํจ๋์ด์ ธ ์๋ค.
โ torch.onnx : ์๋ก๋ค๋ฅธ ๋ฅ๋ฌ๋ ํ๋ ์์ํฌ ๊ฐ์ ๋ชจ๋ธ์ ๊ณต์ ํ ๋ ์ฌ์ฉํ๋ ํฌ๋งท
2๏ธโฃ ํ ์ ์กฐ์ํ๊ธฐ
๐น ๋ฒกํฐ ํ๋ ฌ ํ ์
• ๋ฒกํฐ : 1์ฐจ์์ผ๋ก ๊ตฌ์ฑ๋ ๊ฐ
• ํ๋ ฌ : 2์ฐจ์์ผ๋ก ๊ตฌ์ฑ๋ ๊ฐ
• ํ ์ : 3์ฐจ์ ์ด์์ผ๋ก ๊ตฌ์ฑ๋ ๊ฐ → ๋ฐ์ดํฐ์ฌ์ด์ธ์ค ๋ถ์ผ ํ์ 3์ฐจ์ ์ด์ ํ ์๋ ๊ทธ๋ฅ ๋ค์ฐจ์ ํ๋ ฌ ๋๋ ๋ฐฐ์ด๋ก ๊ฐ์ฃผ
⇒ ๋ฅ๋ฌ๋์ ๋ค๋ฃฐ๋ ํ๋ ฌ ๋๋ ํ ์์ ํฌ๊ธฐ๋ฅผ ๊ณ ๋ คํ๋ ๊ฒ์ ๋งค์ฐ ์ค์
๐น ๊ธฐ๋ณธ ์ธํ : 2D Tensor
• 2D : batch size X dimension
• ์์ : 64 X 256
- ํ๋ จ ๋ฐ์ดํฐ ํ๋์ ํฌ๊ธฐ๊ฐ [3,1,2,5 ... ] ์ด๋ฐ ์ซ์๋ค์ ๋์ด์ด 256๊ฐ๊ฐ ์์ด, 256์ด๋ผ๊ณ ํ๋ค๋ฉด, ํ๋ จ ๋ฐ์ดํฐ ํ๋์ ๋ฒกํฐ์ ์ฐจ์์ 256 ์ด๋ผ๊ณ ๋ณผ ์ ์๋ค.
- ์ด๋ฐ ํ๋ จ ๋ฐ์ดํฐ๊ฐ 3000๊ฐ๊ฐ ์๋ค๊ณ ํ๋ฉด, ์ ์ฒด ๋ฐ์ดํฐ ํฌ๊ธฐ๋ 3000 X 256 ์ด๊ณ ํ๋ ฌ ํํ์ด๋ฏ๋ก 2D ํ ์์ ํด๋นํ๋ค.
- ์ปดํจํฐ๋ ๋ณดํต ๋ฉ์ด๋ฆฌ๋ก ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋๋ฐ, 3000๊ฐ์์ 64๊ฐ์ฉ ๊บผ๋ด ์ฒ๋ฆฌํ๋ค๊ณ ํ๋ฉด ์ด๋ 64๋ฅผ batch size ๋ผ๊ณ ํ๋ค.
- dimension = 256 , batch size = 64
๐น ๋น์ ๋ถ์ผ์์์ ํ ์ : 3D Tensor
• 3D : batchsize , width, height
• ์์ฐ์ด์ฒ๋ฆฌ ๋ณด๋ค ๋น์ (์์, ์ด๋ฏธ์ง) ๋ถ์ผ์์ ๋ ๋ณต์กํ ํ ์๋ฅผ ๋ค๋ฃจ๊ฒ ๋๋ค.
• ์ด๋ฏธ์ง๋ ๊ฐ๋ก , ์ธ๋ก ๊ทธ๋ฆฌ๊ณ ์ฌ๋ฌ ์ฅ์ ์ด๋ฏธ์ง (batch size) ๋ก ๊ตฌ์ฑ๋๋ฉด 3์ฐจ์์ ํ ์๊ฐ ๋๋ค.
→ ์ธ๋ก : batch size , ๊ฐ๋ก : width, ๋์ด : height
๐น ์์ฐ์ด ๋ถ์ผ์์์ ํ ์ : 3D Tensor
• 3D : batchsize , length, dim
• ์์ฐ์ด ์ฒ๋ฆฌ๋ (batch size, ๋ฌธ์ฅ์ ๊ธธ์ด, ๋จ์ด ๋ฒกํฐ์ ์ฐจ์) ์ด๋ผ๋ 3์ฐจ์ ํ ์๋ฅผ ์ฌ์ฉํ๋ค.
• ์์ฐ์ด ์ฒ๋ฆฌ 3D ํ ์ ํ์ฑ ์์
→ ๊ฐ ๋ฐฐ์น์ ํ ์ ํฌ๊ธฐ = (batch size x ๋ฌธ์ฅ๊ธธ์ด x ๋จ์ด๋ฒกํฐ์ ์ฐจ์) = (2 x 3 x 3)
๐น ๋ํ์ด๋ก ํ ์ ๋ง๋ค๊ธฐ
๐น ํ์ดํ ์น ํ ์ ์ ์ธํ๊ธฐ
• import torch
• torch.FloatTensor( [๋ฆฌ์คํธ] )
• torch.dim()
• torch.shape
๐น ๋ธ๋กํธ์บ์คํ ๊ธฐ๋ฅ
• ๋ฅ๋ฌ๋์ ํ๊ฒ๋๋ฉด ํฌ๊ธฐ๊ฐ ๋ค๋ฅธ ํ๋ ฌ ๋๋ ํ ์์ ๋ํด ์ฌ์น์ฐ์ฐ์ ์ํํ ํ์๊ฐ ์๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์ํ๋๋ฐ, ์ด๋ ํ์ดํ ์น์์ ์๋์ผ๋ก ํฌ๊ธฐ๋ฅผ ๋ง์ถฐ ์ฐ์ฐ์ ์ํํ๊ฒ ๋ง๋๋ ๋ธ๋ก๋์บ์คํ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ค.
๐น ํ๋ ฌ ๊ณฑ์
• ํ๋ ฌ ๊ณฑ์ : .matmul
m1.matmul(m2)
• ์์๋ณ ๊ณฑ์ : .mul ํน์ *
m1.mul(m2)
m1*m2
๐น ํ๊ท
• torch.mean()
• torch.mean(dim=n) : ํด๋น ํ(0) ๋๋ ์ด(1) ๋ฐฉํฅ์ ์ ์ธํ ๊ธฐ์ค์ผ๋ก ์ฐ์ฐ ์งํ
๐น ๋ง์
• torch.sum()
๐น ์ต๋์ ์๊ทธ๋งฅ์ค
• torch.max()[0] : ์ต๋๊ฐ์ ๋ฐํ
• torch.max()[1] : ์ต๋๊ฐ์ด ์์นํ ์ธ๋ฑ์ค๋ฅผ ๋ฐํ
๐น ๋ทฐ View - ์์์ ์๋ฅผ ์ ์งํ๋ฉด์ ํ ์์ ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝ
• ๋ํ์ด์ reshape ์ ๋น์ทํ ์ญํ ์ ํ๋ค.
• torch.view( [๋ฐ๊ฟ ์ฐจ์] )
• view ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ณ๊ฒฝ ์ ๊ณผ ํ์ ํ ์ ์์ ์์์ ๊ฐ์๊ฐ ์ ์ง๋์ด์ผ ํ๋ค.
• ํ์ดํ ์น์ view ๋ ์ฌ์ด์ฆ๊ฐ -1๋ก ์ค์ ๋๋ฉด ๋ค๋ฅธ ์ฐจ์์ผ๋ก๋ถํฐ ํด๋น ๊ฐ์ ์ ์ถํ๋ค.
๐น ์คํด์ฆ Squeeze - 1์ธ ์ฐจ์์ ์ ๊ฑฐํ๋ค.
• torch.squeeze()
๐น ์ธ์คํด์ฆ Unsqueeze - ํน์ ์์น์ 1์ธ ์ฐจ์์ ์ถ๊ฐํ๋ค.
• torch.unsqueeze(n) : n+1 ๋ฒ์งธ ์ฐจ์์ 1์ ์ถ๊ฐ
→ view(), squeeze(), unsqueeze() ๋ ํ ์์ ์์์๋ฅผ ๊ทธ๋๋ก ์ ์งํ๋ฉด์ ๋ชจ์๊ณผ ์ฐจ์์ ์กฐ์ ํ๋ค.
๐น ํ์ ์บ์คํ
• torch.LongTensor : 64๋นํธ์ ๋ถํธ ์๋ ์ ์
• torch.cuda.FloatTensor : GPU ์ฐ์ฐ์ ์ํ ์๋ฃํ
• torch.ByteTensor() : ๊ฐ๋ น [True, False] ๋ผ๋ ๋ฆฌ์คํธ๋ฅผ ์ ๋ ฅํ๋ฉด [1,0] ์ผ๋ก ๋ฐํํด์ค๋ค.
• .long() ์ด๋ .float() ๋ก ๊ฐ๋จํ๊ฒ ํ ๋ณํ์ ํ ์๋ ์๋ค.
๐น ์ฐ๊ฒฐํ๊ธฐ concat
• torch.cat( [x,y] , dim = n ) : x ํ ์์ y ํ ์๋ฅผ ์ฐ๊ฒฐํ๋ n ๋ฒ์งธ ์ฐจ์์ ๋๋ฆฌ๋๋ก ์ฐ๊ฒฐ
• ๋ฅ๋ฌ๋์ ์ฃผ๋ก ๋ชจ๋ธ์ ์ ๋ ฅ ๋๋ ์ค๊ฐ ์ฐ์ฐ์์ ๋ ๊ฐ์ ํ ์๋ฅผ ์ฐ๊ฒฐํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค. ๋ ํ ์๋ฅผ ์ฐ๊ฒฐํด์ ์ ๋ ฅ์ผ๋ก ์ฌ์ฉํ๋ ๊ฒ์ ๋ ๊ฐ์ง ์ ๋ณด๋ฅผ ๋ชจ๋ ์ฌ์ฉํ๋ค๋ ์๋ฏธ๋ฅผ ๊ฐ์ง
๐น ์คํํน Stacking
• ์คํํน์ด ๋ง์ ์ฐ์ฐ์ ํฌํจํ๊ณ ์์ด์, ์ฐ๊ฒฐํ๋ ๊ธฐ๋ฅ์ concat ๊ณผ ๋๊ฐ์ง๋ง ์คํํน์ ์ฌ์ฉํ๋๊ฒ ๋ ํธ๋ฆฌํ ์๋ ์๋ค.
• torch.stack( [x,y,z] )
• ๊ฐ์ ๊ธฐ๋ฅ์ concat ์ผ๋ก ๊ตฌํํ๋ ค๋ฉด unsqueeze(0) ์ผ๋ก (1,2) ํฌ๊ธฐ๋ก ๋ฐ๊พธ์ด ์ฃผ์ด์ผ ํ ๋ค์ ์ฐ๊ฒฐํด์ผ ํ๋ฏ๋ก ๊ฝค๋ ๋ณต์กํ๋ค
• dim ์ธ์๋ฅผ ์ง์ ํด์ ํน์ ์ฐจ์์ด ์ฆ๊ฐํ๋๋ก ์กฐ์ ํ ์ ์๋ค.
๐น 0 ์ผ๋ก ์ฑ์์ง ํ ์, 1๋ก ์ฑ์์ง ํ ์
• torch.ones_like()
• torch.zeros_like()
๐น ๋ฎ์ด์ฐ๊ธฐ ์ฐ์ฐ
• ์ฐ์ฐ ๋ค์ _ ํ์๋ฅผ ๋ถ์ด๋ฉด ๊ธฐ์กด์ ๊ฐ์ ๋ฎ์ด์ฐ๊ธฐ ํ๋ค.
• EX : torch.mul_()
3๏ธโฃ ํ์ด์ฌ ํด๋์ค Class
๐น ํจ์์ ํด๋์ค์ ์ฐจ์ด
class Calculator:
def __init__(self): # ๊ฐ์ฒด ์์ฑ ์ ํธ์ถ๋ ๋ ์คํ๋๋ ์ด๊ธฐํ ํจ์. ์ด๋ฅผ ์์ฑ์๋ผ๊ณ ํ๋ค.
self.result = 0
def add(self, num): # ๊ฐ์ฒด ์์ฑ ํ ์ฌ์ฉํ ์ ์๋ ํจ์.
self.result += num
return self.result
• ํด๋์ค๋ ๋ถ์ด๋นต ํ ๊ฐ์ด ํด๋์ค๋ฅผ ์์ฑํ ํ, ์ด๊ฑธ๋ก ๊ฐ์ฒด๋ผ๋ ๊ฒ์ ๋ง๋ค ์ ์๋ค.
• ๋ ๊ฐ์ ๋ง์ ๊ธฐ๋ฅผ ํจ์๋ก ๊ตฌํํ๋ฉด ์๋์ ๊ฐ์๋ฐ
• ์ด๋ฅผ ๋งจ ์์์ ์ ์ํ ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ฉด
cal1 = Calculator()
cal2 = Calculator()
# ๊ฐ์ฒด 2๊ฐ๋ฅผ ์์ฑํ๊ณ
print(cal1.add(3))
print(cal1.add(4))
print(cal2.add(3))
print(cal2.add(7))
# ๊ฐ์ฒด๋ณ๋ก ๋
๋ฆฝ์ ์ธ ์ฐ์ฐ์ ์ํํ ์ ์๋ค.
ํด๋์ค๋ฅผ ํตํด ๋ณ๋์ ๊ฐ์ฒด๋ฅผ ์์ฑํ์ ์ฝ๋๊ฐ ํจ์ฌ ๊ฐ๊ฒฐํด์ง๋ค.
'1๏ธโฃ AIโขDS > ๐ Deep learning' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฅ๋ฌ๋ ํ์ดํ ์น ๊ต๊ณผ์] 2์ฅ ์ค์ต ํ๊ฒฝ ์ค์ ๊ณผ ํ์ดํ ์น ๊ธฐ์ด (1) | 2022.09.23 |
---|---|
[๋ฅ๋ฌ๋ ํ์ดํ ์น ๊ต๊ณผ์] 1์ฅ ๋จธ์ ๋ฌ๋๊ณผ ๋ฅ๋ฌ๋ (0) | 2022.09.22 |
[์ธ๊ณต์ง๋ฅ] ๋ฅ๋ฌ๋ ๋ชจ๋ธ ๊ฒฝ๋ํ (0) | 2022.06.21 |
[์ธ๊ณต์ง๋ฅ] Federated Learning , Distributed Learning (0) | 2022.06.15 |
[์ธ๊ณต์ง๋ฅ] Meta learning , Transfer learning (0) | 2022.06.14 |
๋๊ธ