ํฐ์คํ ๋ฆฌ ๋ทฐ
๐ ํ๋ ์ธ๊ณต์ง๋ฅ ํ์ต 2๋จ๊ณ: ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง(CNN) ์ฌํ์ ์ ์ด ํ์ต
octo54 2025. 5. 14. 11:07๐ ํ๋ ์ธ๊ณต์ง๋ฅ ํ์ต 2๋จ๊ณ: ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง(CNN) ์ฌํ์ ์ ์ด ํ์ต
๐ ํ์ต ๊ธฐ๊ฐ: 7~9๊ฐ์
๐ฏ ํ์ต ๋ชฉํ: CNN ๊ตฌ์กฐ ์ฌํ ํ์ต๊ณผ ์ ์ด ํ์ต ํ์ฉ
๐ 1. CNN์ ํ์์ฑ๊ณผ ํ์ฉ
ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง(Convolutional Neural Network, CNN)์ ์ด๋ฏธ์ง ๋ฐ์ดํฐ ๋ถ์์ ํนํ๋ ์ ๊ฒฝ๋ง์
๋๋ค.
์ด๋ฏธ์ง ๋ถ๋ฅ, ๊ฐ์ฒด ํ์ง, ์ผ๊ตด ์ธ์ ๋ฑ ๋ค์ํ ๋ถ์ผ์์ ํ์ฉ๋ฉ๋๋ค.
์ด๋ฒ ๊ธ์์๋ CNN์ ์ฌํ ๊ตฌ์กฐ์ ์ ์ด ํ์ต์ ์ค์ฌ์ผ๋ก ํ์ตํฉ๋๋ค.
๐ 1-1. CNN ๊ตฌ์กฐ ์ฌํ ์ดํด
CNN์ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋ ํฉ์ฑ๊ณฑ ์ธต(Convolution Layer), ํ์ฑํ ํจ์, ํ๋ง ์ธต(Pooling Layer), **์์ ์ฐ๊ฒฐ ์ธต(Fully Connected Layer)**๋ก ์ด๋ฃจ์ด์ง๋๋ค.
์ฌ๊ธฐ์ **์ ๊ทํ ์ธต(Batch Normalization)**๊ณผ **๋๋กญ์์ ์ธต(Dropout Layer)**์ ์ถ๊ฐํ์ฌ ์ฑ๋ฅ์ ํฅ์ํ ์ ์์ต๋๋ค.
๐ 1) ํฉ์ฑ๊ณฑ ์ฐ์ฐ (Convolution Operation)
ํฉ์ฑ๊ณฑ์ ํํฐ(Filter) ๋๋ ์ปค๋(Kernel)์ ์ด์ฉํ์ฌ ์ด๋ฏธ์ง์ ํน์ง์ ์ถ์ถํฉ๋๋ค.
- ํํฐ: ๊ฐ์ค์น ํ๋ ฌ๋ก ๊ตฌ์ฑ๋์ด ํน์ง ๋งต์ ์์ฑ
- ์คํธ๋ผ์ด๋(Strides): ํํฐ๊ฐ ์ด๋ํ๋ ๊ฐ๊ฒฉ
- ํจ๋ฉ(Padding): ์ด๋ฏธ์ง ๊ฐ์ฅ์๋ฆฌ ์ฒ๋ฆฌ (same, valid)
Python ์์ :
import torch
import torch.nn as nn
# ํฉ์ฑ๊ณฑ ์ฐ์ฐ
conv = nn.Conv2d(in_channels=1, out_channels=3, kernel_size=3, stride=1, padding=1)
x = torch.randn(1, 1, 28, 28) # ๋ฐฐ์น ํฌ๊ธฐ, ์ฑ๋ ์, ๋์ด, ๋๋น
output = conv(x)
print(f"์ถ๋ ฅ ํฌ๊ธฐ: {output.shape}")
๐ก ํฉ์ฑ๊ณฑ์ ์ฅ์ :
- ๊ณต๊ฐ ๋ถ๋ณ์ฑ: ์ด๋ฏธ์ง ์์น ๋ณํ์ ๊ฐ๊ฑด
- ํ๋ผ๋ฏธํฐ ๊ณต์ : ํํฐ๋ฅผ ํตํด ๋์ผํ ๊ฐ์ค์น ์ฌ์ฉ
๐ 2) ํ์ฑํ ํจ์์ ์ ๊ทํ
CNN์์๋ ์ฃผ๋ก ReLU (Rectified Linear Unit) ํ์ฑํ ํจ์๋ฅผ ์ฌ์ฉํฉ๋๋ค.
๋ํ, Batch Normalization์ ํตํด ํ์ต ์๋๋ฅผ ๊ฐ์ ํ๊ณ ๊ณผ์ ํฉ์ ๋ฐฉ์งํฉ๋๋ค.
Python ์์ :
conv = nn.Conv2d(1, 3, 3, padding=1)
bn = nn.BatchNorm2d(3)
relu = nn.ReLU()
x = torch.randn(1, 1, 28, 28)
x = conv(x)
x = bn(x)
x = relu(x)
print(x.shape)
๐ 3) ํ๋ง ์ธต (Pooling Layer)
ํ๋ง์ ํน์ง ๋งต์ ํฌ๊ธฐ๋ฅผ ์ค์ฌ ์ฐ์ฐ๋์ ๊ฐ์์ํค๊ณ , ๊ณผ์ ํฉ์ ๋ฐฉ์งํฉ๋๋ค.
- ์ต๋ ํ๋ง(Max Pooling): ๊ฐ์ฅ ํฐ ๊ฐ ์ถ์ถ
- ํ๊ท ํ๋ง(Average Pooling): ํ๊ท ๊ฐ ์ถ์ถ
Python ์์ :
pool = nn.MaxPool2d(kernel_size=2, stride=2)
x = torch.randn(1, 3, 28, 28)
output = pool(x)
print(f"ํ๋ง ํ ํฌ๊ธฐ: {output.shape}")
๐ 4) ๋๋กญ์์ (Dropout)
๊ณผ์ ํฉ ๋ฐฉ์ง๋ฅผ ์ํด ์ ๊ฒฝ๋ง ์ผ๋ถ๋ฅผ ๋ฌด์์๋ก ๋นํ์ฑํํฉ๋๋ค.
Python ์์ :
dropout = nn.Dropout(p=0.5)
x = torch.randn(5, 10)
output = dropout(x)
print(output)
๐ง 2. CNN ์ํคํ ์ฒ ์ฌ๋ก
๐ 2-1. VGGNet (์ฌ์ธต ์ ๊ฒฝ๋ง ๊ตฌ์กฐ)
- ๊ตฌ์กฐ: ์ฌ๋ฌ ๊ฐ์ ํฉ์ฑ๊ณฑ ์ธต๊ณผ ํ๋ง ์ธต์ ๋ฐ๋ณต์ ์ผ๋ก ์์ ๊ตฌ์กฐ
- ํน์ง: ํํฐ ํฌ๊ธฐ๋ฅผ ์ค์ด๊ณ ๊น์ด๋ฅผ ์ฆ๊ฐ์์ผ ์ฑ๋ฅ ํฅ์
- ํ์ฉ: ์ด๋ฏธ์ง ๋ถ๋ฅ, ์ ์ด ํ์ต
VGG ๊ตฌ์กฐ ์์ :
class VGGNet(nn.Module):
def __init__(self):
super(VGGNet, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.Conv2d(64, 64, kernel_size=3, padding=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
self.fc = nn.Sequential(
nn.Linear(64 * 14 * 14, 256),
nn.ReLU(),
nn.Linear(256, 10)
)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.fc(x)
return x
model = VGGNet()
print(model)
๐ 3. ์ ์ด ํ์ต (Transfer Learning)
์ด๋ฏธ ํ์ต๋ ๋ชจ๋ธ์ ๊ฐ์ค์น๋ฅผ ํ์ฉํ์ฌ ์๋ก์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ธฐ๋ฒ์
๋๋ค.
์ฃผ๋ก ๋๊ท๋ชจ ๋ฐ์ดํฐ์
์ผ๋ก ์ฌ์ ํ์ต๋ ๋ชจ๋ธ์ ์์ ๋ฐ์ดํฐ์
์ ๋ฏธ์ธ ์กฐ์ (Fine-Tuning)ํ์ฌ ์ฌ์ฉํฉ๋๋ค.
๐ป ์ฝ๋ ์ค์ต: ์ ์ด ํ์ต์ ํ์ฉํ ์ด๋ฏธ์ง ๋ถ๋ฅ (ResNet)
from torchvision import models, transforms
from PIL import Image
# ์ฌ์ ํ์ต๋ ๋ชจ๋ธ ๋ถ๋ฌ์ค๊ธฐ
model = models.resnet18(pretrained=True)
model.eval()
# ์ด๋ฏธ์ง ์ ์ฒ๋ฆฌ
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor()
])
image = Image.open("sample.jpg")
x = preprocess(image).unsqueeze(0)
# ์์ธก
with torch.no_grad():
output = model(x)
print(f"์์ธก ๊ฒฐ๊ณผ: {output.argmax(1).item()}")
๐ก ์ ์ด ํ์ต ์ฅ์ :
- ์๊ฐ ์ ์ฝ: ์ฌ์ ํ์ต๋ ๊ฐ์ค์น๋ฅผ ์ฌ์ฉํ์ฌ ๋น ๋ฅธ ๋ชจ๋ธ ๊ตฌ์ถ
- ์ฑ๋ฅ ํฅ์: ๋๊ท๋ชจ ๋ฐ์ดํฐ์ ์ผ๋ก ํ์ต๋ ํน์ฑ ํ์ฉ
๐ป ์ค์ต ํ๋ก์ ํธ: ์ ์ด ํ์ต์ ์ด์ฉํ ๊ฝ ์ด๋ฏธ์ง ๋ถ๋ฅ
- ๋ชฉํ: ๊ฝ์ ์ข ๋ฅ๋ฅผ ์ด๋ฏธ์ง๋ก ์์ธก
- ๋ฐ์ดํฐ์ : ๊ฝ ๋ฐ์ดํฐ (5์ข ๋ฅ)
- ๋ชจ๋ธ: ์ ์ด ํ์ต (ResNet)
- ํ๊ฐ ์งํ: ์ ํ๋
์ฝ๋:
from torchvision import datasets
from torch.utils.data import DataLoader
# ๋ฐ์ดํฐ์
๋ก๋
train_dataset = datasets.FakeData(transform=transforms.ToTensor())
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
# ์ ์ด ํ์ต ๋ชจ๋ธ ์ค์
model = models.resnet18(pretrained=True)
model.fc = nn.Linear(512, 5) # ์ถ๋ ฅ ์ฐจ์ ์กฐ์
# ํ์ต ๋ฃจํ
optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()
for epoch in range(5):
for inputs, labels in train_loader:
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")
๐ ํ์ต ์ฒดํฌ๋ฆฌ์คํธ:
- CNN์ ๊ตฌ์กฐ์ ๊ฐ ์ธต์ ์ญํ ์ ์ดํดํ๊ณ ํ์ฉํ ์ ์๋ค.
- VGGNet๊ณผ ResNet ๊ฐ์ ์ฌ์ธต ์ ๊ฒฝ๋ง ๊ตฌ์กฐ๋ฅผ ์ดํดํ๋ค.
- ์ ์ด ํ์ต์ ์ฌ์ฉํ์ฌ ์๋ก์ด ์ด๋ฏธ์ง ๋ถ๋ฅ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
- PyTorch๋ฅผ ํ์ฉํ์ฌ ์ฌ์ ํ์ต ๋ชจ๋ธ์ ๋ถ๋ฌ์ค๊ณ ๋ฏธ์ธ ์กฐ์ ํ ์ ์๋ค.
CNN, ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง, VGGNet, ResNet, ์ ์ด ํ์ต, ์ด๋ฏธ์ง ๋ถ๋ฅ, ๋ฅ๋ฌ๋, PyTorch, ํ์ต ์ ์ด, ์ฌ์ธต ์ ๊ฒฝ๋ง, ๋ชจ๋ธ ์ฌ์ฌ์ฉ
'Programming > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
- Total
- Today
- Yesterday
- seo ์ต์ ํ 10๊ฐ
- ์น๊ฐ๋ฐ
- Prisma
- ๋ฐฑ์๋๊ฐ๋ฐ
- ๊ด๋ฆฌ์
- rag
- ํ๋ก ํธ์๋๋ฉด์
- Webpack
- llm
- REACT
- NestJS
- ๊ฐ๋ฐ๋ธ๋ก๊ทธ
- PostgreSQL
- nodejs
- SEO์ต์ ํ
- fastapi
- LangChain
- gatsbyjs
- Python
- ํ๋ก ํธ์๋
- nextJS
- AI์ฑ๋ด
- Docker
- CI/CD
- ํ์ด์ฌ ์๊ณ ๋ฆฌ์ฆ
- Next.js
- Ktor
- github
- App Router
- kotlin
์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | ||||
4 | 5 | 6 | 7 | 8 | 9 | 10 |
11 | 12 | 13 | 14 | 15 | 16 | 17 |
18 | 19 | 20 | 21 | 22 | 23 | 24 |
25 | 26 | 27 | 28 | 29 | 30 | 31 |