https://colab.research.google.com/drive/1j9ghqmP-QboSbipZ7LjzbRrpTq4Mhqo8?usp=sharing
1๏ธโฃ ์ธ๊ณต ์ ๊ฒฝ๋ง์ ํ๊ณ์ ๋ฅ๋ฌ๋ ์ถํ
๐น XOR ๋น์ ํ ๋ฌธ์
๐ ํผ์ ํธ๋ก
• ์ ํ ๋ถ๋ฅ๊ธฐ๋ก ๋ฅ๋ฌ๋์ ๊ธฐ์์ด ๋๋ ์๊ณ ๋ฆฌ์ฆ
• ๋ค์์ ์ ํธ๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ ํ๋์ ์ ํธ (1 ๋๋ 0 : ํ๋ฅธ๋ค/์ํ๋ฅธ๋ค) ๋ฅผ ์ถ๋ ฅ
๐ ๋ ผ๋ฆฌ ๊ฒ์ดํธ
• OR ๊ณผ AND ๊ฒ์ดํธ๋ ๋ฐ์ดํฐ๊ฐ ์ ํ์ ์ผ๋ก ๋ถ๋ฆฌ๋๋ค.
• XOR ๊ฒ์ดํธ๋ ๋ฒ ํ์ ๋ ผ๋ฆฌํฉ ๊ตฌ์กฐ (์ ๋ ฅ ๋๊ฐ ์ค ํ๊ฐ๋ง 1์ผ ๋ ์๋ํ๋ ๋ ผ๋ฆฌ์ฐ์ฐ) ๋ฅผ ๊ฐ์ง๊ณ ์๋๋ฐ, ์ด๋ ๋น์ ํ์ ์ผ๋ก ๋ถ๋ฆฌ๋๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์๊ธฐ ๋๋ฌธ์ ๋จ์ธต ํผ์ ํธ๋ก(์ ํ ๋ถ๋ฅ๊ธฐ) ๋ ํ์ต์ด ๋ถ๊ฐ๋ฅํ๋ค.
• MLP ๋ค์ธต ํผ์ ํธ๋ก → XOR ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ํ๋ ์ด์์ ์๋์ธต์ ๋์ด์ ๋น์ ํ์ ์ธ ํ์ต์ด ๊ฐ๋ฅํ๋๋ก ํจ
2๏ธโฃ ๋ฅ๋ฌ๋ ๊ตฌ์กฐ
๋ฅ๋ฌ๋ : ์ฌ๋ฌ ์ธต์ ๊ฐ์ง ์ธ๊ณต์ ๊ฒฝ๋ง์ ์ฌ์ฉํด ํ์ต์ ์ํ
๐น ๋ฅ๋ฌ๋ ๊ธฐ๋ณธ ์ฉ์ด ์ ๋ฆฌ
โ ๊ฐ์ค์น
โ ์ ๋ ฅ๊ฐ (ํ๋ จ ๋ฐ์ดํฐ) ์ด ์ฐ์ฐ๊ฒฐ๊ณผ์ ๋ฏธ์น๋ ์ํฅ๋ ฅ์ ์กฐ์ ํ๋ ์์
โก ๊ฐ์คํฉ ๋๋ ์ ๋ฌํจ์
โ ๊ฐ ๋ ธ๋์์ ๋ค์ด์ค๋ ์ ํธ์ ๊ฐ์ค์น๋ฅผ ๊ณฑํด ๋ค์ ๋ ธ๋๋ก ์ ๋ฌ๋๋๋ฐ ์ด ๊ฐ์ ๋ชจ๋ ๋ํ ํฉ๊ณ๋ฅผ ๊ฐ์คํฉ์ด๋ผ๊ณ ํ๋ค.
โ ๊ฐ์คํฉ์ ํ์ฑํ ํจ์๋ก ๋ณด๋ด์ง๊ธฐ ๋๋ฌธ์ ์ ๋ฌํจ์๋ผ๊ณ ๋ ํ๋ค.
โข ํ์ฑํ ํจ์
โ ์ผ์ ๊ธฐ์ค์ ๋ฐ๋ผ ์ถ๋ ฅ ๊ฐ์ ๋ณํ์ํค๋ ๋น์ ํ ํจ์
โ ์๊ทธ๋ชจ์ด๋, ํ์ดํผ๋ณผ๋ฆญ ํ์ ํธ, ๋ ๋ฃจ ๋ฑ์ ์ข ๋ฅ๊ฐ ์๋ค.
(1) ์๊ทธ๋ชจ์ด๋
- ์ ํ ํจ์์ ๊ฒฐ๊ณผ๋ฅผ 0๊ณผ 1์ฌ์ด์์ ๋น์ ํ ํํ๋ก ๋ณํ
- ๋ถ๋ฅ ๋ฌธ์ ๋ฅผ ํ๋ฅ ์ ์ผ๋ก ํํํ๋๋ฐ ์ฌ์ฉ EX. ๋ก์ง์คํฑ ํ๊ท
- ๊ธฐ์ธ๊ธฐ ์๋ฉธ ๋ฌธ์ ์กด์ฌ
(2) ํ์ดํผ๋ณผ๋ฆญ ํ์ ํธ ํจ์
- ์ ํํจ์ ๊ฒฐ๊ณผ๋ฅผ -1 ๊ณผ 1 ์ฌ์ด์์ ๋น์ ํ ํํ๋ก ๋ณํ
- ์๊ทธ๋ชจ์ด๋์ ์์๋ก ํธํฅ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ผ๋ ๊ธฐ์ธ๊ธฐ ์๋ฉธ ๋ฌธ์ ๋ ์ฌ์ ํ ์กด์ฌ
(3) ๋ ๋ฃจ ํจ์
- ์ต๊ทผ ํ๋ฐํ ์ฌ์ฉ๋๋ ํจ์
- ์ ๋ ฅ์ด ์์ → 0์ ์ถ๋ ฅ
- ์ ๋ ฅ์ด ์์ → ์ซ์ ๊ทธ๋๋ก๋ฅผ ์ถ๋ ฅ (y=x)
- ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ํฅ์ ์ฃผ์ง ์์ (๋ํจ์ ๋ฏธ๋ถํด๋ 1) ํ์ต ์๋๊ฐ ๋น ๋ฅด๊ณ ๊ธฐ์ธ๊ธฐ ์๋ฉธ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ง ์์
- ๋ ๋ฃจ ํจ์๋ ์ผ๋ฐ์ ์ผ๋ก ์๋์ธต์์ ์ฌ์ฉ๋๋ค.
- ๋จ์ : ์์๊ฐ์ ๋ฐ์ผ๋ฉด 0์ ์ถ๋ ฅํ๋ฏ๋ก ํ์ต ๋ฅ๋ ฅ์ด ๊ฐ์ → ๋ฆฌํค ๋ ๋ฃจ ํจ์ ๋ฑ์ฅ
(4) ๋ฆฌํค๋ ๋ฃจ ํจ์
- ์ ๋ ฅ๊ฐ์ด ์์์ด๋ฉด 0.0001 ์ฒ๋ผ ๋งค์ฐ ์์ ์๋ฅผ ๋ฐํํ๊ฒ ํ์ฌ ๋ ๋ฃจ ํจ์์ ๋ฌธ์ ์ ์ ํด๊ฒฐ
(5) ์ํํธ๋งฅ์ค ํจ์
- ์ ๋ ฅ๊ฐ์ 0~1 ์ฌ์ด๋ก ์ถ๋ ฅ๋๋๋ก ์ ๊ทํํ์ฌ ์ถ๋ ฅ๊ฐ๋ค์ ์ดํฉ์ด ํญ์ 1์ด ๋๋๋ก ํ๋ค.
- ๋ณดํต ์ถ๋ ฅ ๋ ธ๋์ ํ์ฑํ ํจ์๋ก ๋ง์ด ์ฌ์ฉ๋๋ค.
import torch
import torch.nn as nn
class Net(torch.nn.Module) :
def __init__(self, n_feature, n_hidden, n_output) :
super(Net, self).__init__()
self.hidden = torch.nn.Linear(n_feature, n_hidden) # ์๋์ธต
self.relu = torch.nn.ReLu(inplace=True) # ๋ ๋ฃจ ํ์ฑํ ํจ์
self.out = torch.nn.Linear(n_hidden, n_output) # ์ถ๋ ฅ์ธต
self.softmax = torch.nn.Softmax(dim = n_output) # ์ํํธ๋งฅ์ค ํ์ฑํ ํจ์
def forward(self, x) :
x = self.hidden(x)
x = self.relu(x) # ์๋์ธต์ ์ํ ๋ ๋ฃจ ํจ์
x = self.out(x)
x = self.softmax(x) # ์ถ๋ ฅ์ธต์ ์ํ ์ํํธ๋งฅ์ค ํ์ฑํ ํจ์
๐จ ๋น์ ํ ํจ์ : ์ง์ ์ผ๋ก ํํํ ์ ์๋ ๋ฐ์ดํฐ ์ฌ์ด์ ๊ด๊ณ๋ฅผ ํํํ๋ ํจ์
๐จ ๊ธฐ์ธ๊ธฐ ์๋ฉธ ๋ฌธ์ : ํ์ฑํ ํจ์ ๊ณ์ฐ ๊ณผ์ ์์ ๋ํจ์ ๊ฐ์ด ๊ณ์ ๊ณฑํด์ง๋ฉฐ ๊ฐ์ค์น ๊ฒฐ๊ณผ๊ฐ์ด 0์ด ๋์ด ๋์ด์ ๊ณ์ฐ์ด ๋ถ๊ฐ๋ฅํ ์ํ
โฃ ์์คํจ์
๐ ๊ฒฝ์ฌํ๊ฐ๋ฒ
• ํ์ต๋ฅ learning rate ์ ์์คํจ์์ ์๊ฐ ๊ธฐ์ธ๊ธฐ๋ฅผ ์ด์ฉํด ๊ฐ์ค์น๋ฅผ ์ ๋ฐ์ดํธ ํ๋ ๋ฐฉ๋ฒ
• ๋ฏธ๋ถ์ ๊ธฐ์ธ๊ธฐ๋ฅผ ์ด์ฉํด ์ค์ฐจ๋ฅผ ๋น๊ตํ๊ณ ์ด๋ฅผ ์ต์ํ ํ๋ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ ๋ฐฉ๋ฒ
๐ ์์คํจ์
• ์ค์ฐจ๋ฅผ ๊ตฌํ๋ ๋ฐฉ๋ฒ , ํ์ต์ ํตํด ์ป์ ๋ฐ์ดํฐ์ ์ถ์ ์น๊ฐ ์ค์ ๋ฐ์ดํฐ์ ์ผ๋ง๋ ์ฐจ์ด๊ฐ ๋๋์ง ํ๊ฐํ๋ ์งํ
• ๊ฐ์ด ํด์๋ก ๋ง์ด ํ๋ ธ๋ค๋ ์๋ฏธ
(1) ์์คํจ์ - ํ๊ท ์ ๊ณฑ์ค์ฐจ MSE
• ํ๊ท์์ ์ฃผ๋ก ์ฌ์ฉํ๋ ์์คํจ์
loss_fn = torch.nn.MSELoss(reduction = 'sum')
y_pred = model(x)
loss = loss_fn(y_pred, y)
(2) ์์คํจ์ - ํฌ๋ก์ค ์ํธ๋กํผ ์ค์ฐจ
• ๋ถ๋ฅ๋ฌธ์ ์์ ์ํซ์ธ์ฝ๋ฉ์ ํ์ ๋์๋ง ์ฌ์ฉ
• ํฌ๋ก์ค์ํธ๋กํผ๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ ๊ณผ์ ์์ ํ์ต์ด ์ง์ญ ์ต์์ ์์ ๋ฉ์ถ ์ ์๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํ์ฌ ์์ฐ ๋ก๊ทธ๋ฅผ ๋ชจ๋ธ์ ์ถ๋ ฅ๊ฐ์ ์ทจํ๋ค.
loss = nn.CrossEntropyLoss() # โญ
input = torch.randn(5,6, requires_grad = True) # 5x6 ํ๋ ฌ
# torch.randn : ํ๊ท ์ด 0์ด๊ณ ํ์คํธ์ฐจ๊ฐ 1์ธ ๊ฐ์ฐ์์ ์ ๊ท๋ถํฌ๋ฅผ ์ด์ฉํด ์ซ์๋ฅผ ์์ฑ
target = torch.empty(3, dtype = torch.long).random_(5) # ๊ธธ์ด๊ฐ 3์ธ ๋ฒกํฐ
# torch.empty.random_() : 5 ์ดํ์ ๋๋คํ ๊ฐ (float32) ์ผ๋ก ์ฑ์์ง ํ
์๋ฅผ ๋ฐํ
output = loss(input, target) # โญ
output.backward()
๐น ๋ฅ๋ฌ๋ ํ์ต
โ ์์ ํ
โ ํ๋ จ๋ฐ์ดํฐ๊ฐ ๋คํธ์ํฌ๊ฒ ์ ๋ ฅ ๋์์ ๋, ์ ์ฒด ์ ๊ฒฝ๋ง์ ๊ต์ฐจํด ๋๊ฐ๋ ๊ณผ์
โ ๋ชจ๋ ๋ด๋ฐ์ด ์ด์ ์ธต์ ๋ด๋ฐ์์ ์์ ํ ์ ๋ณด์, ๊ฐ์คํฉ๊ณผ ํ์ฑํ ํจ์๋ฅผ ์ ์ฉํ์ฌ ๋ค์์ธต์ ๋ด๋ฐ์ผ๋ก ์ ์ก
โก ์ญ์ ํ
โ ์์ ํ๊ฐ ์๋ฃ๋๋ฉด, ์ต์ข ์ถ๋ ฅ์ธต์์ ๋์ถ๋ ์์ธก๊ฐ๊ณผ ์ค์ ๊ฐ์ ์ฐจ์ด๋ฅผ ์์คํจ์๋ก ์ถ์ ํ๊ณ , ์์คํจ์๊ฐ ๊ฒฐ๊ณผ์ ์ผ๋ก 0์ ๊ฐ๊น๋๋ก ํ๊ธฐ ์ํด ๋ชจ๋ธ์ด ํ๋ จ์ ๋ฐ๋ณตํ๋ฉฐ ๊ฐ์ค์น๋ฅผ ์กฐ์ ํ๋ค.
โ ์ค์ฐจ๊ฐ ๊ณ์ฐ๋๋ฉด ์ถ๋ ฅ์ธต → ์๋์ธต → ์ ๋ ฅ์ธต ์์ผ๋ก ์ ๋ณด๊ฐ ์ญ์ผ๋ก ์ ํ๋๋ค.
๐น ๋ฅ๋ฌ๋ ํ์ต ์ ๋ฌธ์ ์
โ ๊ณผ์ ํฉ
โ ํ๋ จ ๋ฐ์ดํฐ๋ฅผ ๊ณผํ๊ฒ ํ์ตํด์ ์๋ก์ด ๋ฐ์ดํฐ์์๋ ํ์ต์ด ์ ์๋๋ ํ์ (๊ฒ์ฆ ๋ฐ์ดํฐ์๋ ์ค์ฐจ๊ฐ ์ฆ๊ฐํ๊ฒ ๋จ)
โ Solution : Dropout
import torch.nn.functional as F
class DropoutModel(torch.nn.Module) :
def __init__(self) :
super(DropoutModel, self).__init__()
self.layer1 = torch.nn.Linear(784,1200)
self.droppout1 = torch.nn.Dropout(0.5) # 50% ๋
ธ๋๋ฅผ ๋ฌด์์๋ก ์ ํํด ์ฌ์ฉํ์ง ์๊ฒ ๋ค๋ ์๋ฏธ
self.layer2 = torch.nn.Linear(1200, 1200)
self.dropout2 = torch.nn.Droput(0.5)
self.layer3 = torch.nn.Linear(1200,10)
def forward(self,x) :
x = F.relu(self.layer1(x))
x = self.dropout1(x)
x = F.relu(self.layer2(x))
x = self.dropout2(x)
return self.layer3(x)
๐จ torch.nn.funtional : https://pytorch.org/docs/stable/nn.functional.html
โก ๊ธฐ์ธ๊ธฐ ์๋ฉธ
โ ์ถ๋ ฅ์ธต์์ ์๋์ธต์ผ๋ก ์ ๋ฌ๋๋ ์ค์ฐจ๊ฐ ํฌ๊ฒ ์ค์ด๋ค์ด ํ์ต์ด ๋์ง ์๋ ํ์
โ ๊ธฐ์ธ๊ธฐ๊ฐ ์๋ฉธ๋์ด ํ์ต์ด ๋๋๊ฒ ์งํ๋๋ค ์ค์ฐจ๋ฅผ ๋ ์ค์ด์ง ๋ชปํ๊ณ ๊ทธ ์ํ๋ก ์๋ ดํ๋ ํ์
โ Solution : ๋ ๋ฃจ ํ์ฑํ ํจ์๋ฅผ ์ฌ์ฉํ๊ธฐ
โข ์ฑ๋ฅ์ด ๋๋น ์ง๋ ๋ฌธ์ ๋ฐ์ → ๋ค์ํ ๊ฒฝ์ฌํ๊ฐ๋ฒ ๋ฐฉ์ ๋ฑ์ฅ, ์ตํฐ๋ง์ด์
โ ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์์คํจ์์ ๋น์ฉ์ด ์ต์๊ฐ ๋๋ ์ง์ ์ ์ฐพ์ ๋๊น์ง ๊ธฐ์ธ๊ธฐ๊ฐ ๋ฎ์ ์ชฝ์ผ๋ก ๊ณ์ ์ด๋ํ๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๋๋ฐ, ์ด๋ local minimum ์ ๋น ์ ธ global minimum ์ ์ฐพ์ง ๋ชปํด ์ฑ๋ฅ์ด ๋๋น ์ง๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.
(1) ๋ฐฐ์น ๊ฒฝ์ฌ ํ๊ฐ๋ฒ BGD
• ์ ์ฒด ํ๋ จ ๋ฐ์ดํฐ์ ์ ๋ํด ๊ฐ์ค์น๋ฅผ ํธ๋ฏธ๋ถ ํ๋ ๋ฐฉ๋ฒ
• ๊ธฐ์ธ๊ธฐ๋ฅผ ํ ๋ฒ๋ง ๊ณ์ฐํด ์ ๋ฐ์ดํธ
• ๋จ์ : ํ์ต์ด ์ค๋๊ฑธ๋ฆผ
(2) ํ๋ฅ ์ ๊ฒฝ์ฌ ํ๊ฐ๋ฒ SGD
• ์์๋ก ์ ํํ ๋ฐ์ดํฐ์ ๋ํด ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ณ์ฐํ๋ ๋ฐฉ๋ฒ
• ์ ์ ๋ฐ์ดํฐ๋ฅผ ์ฌ์ฉํ๋ฏ๋ก ๋น ๋ฅธ ๊ณ์ฐ์ด ๊ฐ๋ฅ
• ํ๋ผ๋ฏธํฐ ๋ณ๊ฒฝํญ์ด ๋ถ์์ ํ๊ณ , ๋๋ก ์ ํ๋๊ฐ BGD ๋ณด๋ค ๋ฎ์ ์ ์์ง๋ง ํ์ต ์๋๊ฐ ๋น ๋ฅด๋ค.
(3) ๋ฏธ๋๋ฐฐ์น ๊ฒฝ์ฌ ํ๊ฐ๋ฒ
• ๋ฐ์ดํฐ๋ฅผ ๋ฏธ๋๋ฐฐ์น ์ฌ๋ฌ๊ฐ๋ก ๋๋๊ณ , ๋ฏธ๋๋ฐฐ์น ํ ๊ฐ๋ง๋ค ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ตฌํ ํ, ๊ทธ๊ฒ์ ํ๊ท ๊ธฐ์ธ๊ธฐ๋ฅผ ์ด์ฉํด ๋ชจ๋ธ์ ์ ๋ฐ์ดํธ ํด์ ํ์ตํ๋ ๋ฐฉ์
• ํ๋ฅ ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ๋ณด๋ค ์์ ์ ์ด๋ผ ๋ง์ด ์ฌ์ฉ๋๋ ๋ฐฉ๋ฒ์ด๋ค.
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
class CustomDataset(Dataset) :
def __init__(self) :
self.x_data = [[1,2,3],[4,5,6],[7,8,9]]
self.y_data = [[12],[18],[11]]
def __len__(self) :
return len(self.x_data)
def __getitem__(self,idx) :
x = torch.FloatTensor(self.x_data[idx])
y = torch.FloatTensor(self.y_data[idx])
return x, y
dataset = CustomDataset()
dataloader = DataLoader(
dataset,
batch_size = 2 # ๋ฏธ๋๋ฐฐ์นํฌ๊ธฐ๋ก 2์ ์ ๊ณฑ์๋ฅผ ์ฌ์ฉํ๊ฒ ๋ค๋ ์๋ฏธ
suffle = True # ๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฌ์ฌ๋๋ง๋ค ๋๋ค์ผ๋ก ์์ด ๋ถ๋ฌ์ด
)
(4) ์ตํฐ๋ง์ด์
โ ํ๋ฅ ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ํ๋ผ๋ฏธํฐ ๋ณ๊ฒฝ ํญ์ด ๋ถ์์ ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ํ์ต ์๋์ ์ด๋๋์ ์กฐ์ ํ๋ optimizer ๋ฅผ ์ ์ฉํด๋ณผ ์ ์๋ค.
โ ์๋์กฐ์ : Adagrad, Adadelta, RMSProp
• torch.optim.Adagrad(model.parameters(), lr = 0.01)
• torch.optim.Adadelta(model.parameters(), lr = 1.0)
• torch.optim.RMSprop(model.parameters(), lr = 0.01)
โ ์ด๋๋ ์กฐ์ : Momentum, NAG
• torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
• torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, nesterov = True)
โ ํผ์ฉ : Adam
• torch.optim.Adam(model.parameters(), lr=0.01)
๐น ๋ฅ๋ฌ๋์ ์ด์
โ ํน์ฑ ์ถ์ถ
โ ์ฌ๋์ด ์ง์ feature ๋ฅผ ์ ์ํด์ฃผ์ด์ผ ํ๋ ์ ํต์ ์ธ ๋จธ์ ๋ฌ๋ ๋ฐฉ๋ฒ๋ก ๊ณผ ๋ฌ๋ฆฌ ๋ฅ๋ฌ๋์์๋ ์ค์ค๋ก ํน์ฑ์ ์ถ์ถํด๋ธ๋ค.
โก ๋น ๋ฐ์ดํฐ์ ํจ์จ์ ํ์ฉ
โ ๋ฅ๋ฌ๋์ ๋ฐ์ดํฐ ์ฌ๋ก๊ฐ ๋ง์์๋ก ์ฑ๋ฅ์ด ํฅ์๋๋ค.
โ ํ๋ณด๋ ๋ฐ์ดํฐ๊ฐ ์ ๋ค๋ฉด, ๋ฅ๋ฌ๋์ ์ฑ๋ฅ ํฅ์์ ๊ธฐ๋ํ๊ธฐ ์ด๋ ค์ฐ๋ฏ๋ก ๋จธ์ ๋ฌ๋์ ๊ณ ๋ คํด์ผ ํ๋ค.
3๏ธโฃ ๋ฅ๋ฌ๋ ์๊ณ ๋ฆฌ์ฆ
๐น ์ฌ์ธต ์ ๊ฒฝ๋ง
โ ๋ค์์ ์๋์ธต์ ํฌํจํ๋ ์ธ๊ณต์ ๊ฒฝ๋ง
โ ์ฐ์ฐ๋์ด ๋ง๊ณ ๊ธฐ์ธ๊ธฐ ์๋ฉธ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋กญ์์, ๋ ๋ฃจํจ์, ๋ฐฐ์น ์ ๊ทํ ๋ฑ์ ์ ์ฉํ๋ค.
๐น ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง
โ Convolutional layer + Pooling layer
โ ์ด๋ฏธ์ง ์ฒ๋ฆฌ ์ฑ๋ฅ์ด ์ข์ ์ธ๊ณต ์ ๊ฒฝ๋ง ์๊ณ ๋ฆฌ์ฆ
โ ๊ฐ์ฒด ํ์, ๊ฐ์ฒด ์์น๋ฅผ ์ฐพ์๋ด๋๋ฐ ์ ์ฉํ ์ ๊ฒฝ๋ง
๐น ์ํ ์ ๊ฒฝ๋ง
โ ์๊ณ์ด ๋ฐ์ดํฐ (์์ , ์์ ๋ฑ) ๊ฐ์ ์๊ฐ ํ๋ฆ์ ๋ฐ๋ผ ๋ณํํ๋ ๋ฐ์ดํฐ๋ฅผ ํ์ตํ๊ธฐ ์ํ ์ธ๊ณต ์ ๊ฒฝ๋ง ์ด๋ค.
โ ์ํ = ์๊ธฐ ์์ ์ ์ฐธ์กฐ = ํ์ฌ ๊ฒฐ๊ณผ๊ฐ ์ด์ ๊ฒฐ๊ณผ์ ์ฐ๊ด์ด ์๋ค๋ ์๋ฏธ
โ ๋ฐ์ดํฐ๋ ๋์ ์ด๊ณ ๊ธธ์ด๊ฐ ๊ฐ๋ณ์ ์ด๋ค.
โ ์ธ์ด๋ชจ๋ธ๋ง, ํ ์คํธ ์์ฑ, ์๋๋ฒ์ญ, ์์ฑ์ธ์, ์ด๋ฏธ์ง ์บก์ ์์ฑ ๋ฑ ๋ค์ํ ์์๊ฐ ์๋ค.
๐น ์ ํ๋ ๋ณผ์ธ ๋ง ๋จธ์
โ ๊ฐ์์ธต
๐น ์ฌ์ธต ์ ๋ขฐ ์ ๊ฒฝ๋ง
๋จธ์ ๋ฌ๋๊ณผ ๋ฅ๋ฌ๋์ ์ฐ๋ฆฌ๊ฐ ์ป๊ณ ์ถ์ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ๊ธฐ ์ํ ๋๊ตฌ์ด๋ค. ์ด๋ค ๋๊ตฌ๋ฅผ ์ ํํ์ ๋ ๋ ์ข์ ์ฑ๋ฅ๊ณผ ํจ๊ณผ๋ฅผ ์ป์์ง๋ ๋ฐ์ดํฐ๋ฅผ ์์งํ๊ณ ๋ถ์ํ๋ ์ฌ๋๋ง์ด ์ ์ ์๋ค.
'1๏ธโฃ AIโขDS > ๐ Deep learning' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฅ๋ฌ๋ ํ์ดํ ์น ๊ต๊ณผ์] 7์ฅ ์๊ณ์ด I (1) | 2022.11.10 |
---|---|
[๋ฅ๋ฌ๋ ํ์ดํ ์น ๊ต๊ณผ์] 5์ฅ ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง โ (0) | 2022.10.06 |
[๋ฅ๋ฌ๋ ํ์ดํ ์น ๊ต๊ณผ์] 2์ฅ ์ค์ต ํ๊ฒฝ ์ค์ ๊ณผ ํ์ดํ ์น ๊ธฐ์ด (1) | 2022.09.23 |
[๋ฅ๋ฌ๋ ํ์ดํ ์น ๊ต๊ณผ์] 1์ฅ ๋จธ์ ๋ฌ๋๊ณผ ๋ฅ๋ฌ๋ (0) | 2022.09.22 |
[Pytorch ๋ฅ๋ฌ๋ ์ ๋ฌธ] ํ์ดํ ์น ๊ธฐ์ด (0) | 2022.09.14 |
๋๊ธ