본문 바로가기
AI Framework/PyTorch

[PyTorch] 11주차: 모델의 성능 향상 기법

by cogito21_python 2024. 5. 30.
반응형

강의 목표

  • 모델의 성능을 향상시키기 위한 다양한 기법 이해
  • 하이퍼파라미터 튜닝과 모델 앙상블 방법 학습
  • 모델의 성능을 향상시키기 위한 실습 및 프로젝트 수행

강의 내용

1. 모델 성능 향상 개요

  • 모델 성능 향상의 필요성
    • 모델의 예측 성능을 최대화하고, 과적합 및 과소적합 문제 해결
    • 실전 프로젝트에서의 성능 향상의 중요성

2. 하이퍼파라미터 튜닝

  • 하이퍼파라미터 튜닝 개념
    • 모델 학습에 영향을 미치는 하이퍼파라미터의 중요성
    • 하이퍼파라미터 최적화의 필요성
  • 튜닝 방법
    • 그리드 서치(Grid Search)
    • 랜덤 서치(Random Search)
    • 베이즈 최적화(Bayesian Optimization)
     
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

# 하이퍼파라미터 그리드 설정
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20, 30]
}

# 모델 및 그리드 서치 객체 생성
model = RandomForestClassifier()
grid_search = GridSearchCV(estimator=model, param_grid=param_grid, cv=3)

# 데이터 로드 (예시용 데이터)
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)

# 그리드 서치 수행
grid_search.fit(X, y)
print(f'Best parameters found: {grid_search.best_params_}')

 

3. 모델 앙상블

  • 모델 앙상블 개념
    • 여러 모델을 결합하여 예측 성능 향상
    • 앙상블 방법: 배깅(Bagging), 부스팅(Boosting), 스태킹(Stacking)
  • 배깅(Bagging)
    • 랜덤 포레스트(Random Forest) 등
    • 다수결 투표 또는 평균을 통해 최종 예측 도출
     
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 데이터 로드 및 분할
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 랜덤 포레스트 모델 학습
model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

# 예측 및 평가
y_pred = model.predict(X_test)
print(f'Accuracy: {accuracy_score(y_test, y_pred)}')

 

  •  부스팅(Boosting)
    • Gradient Boosting, XGBoost, LightGBM 등
    • 이전 모델의 오차를 보완하며 순차적으로 모델 학습
     
from xgboost import XGBClassifier
from sklearn.metrics import accuracy_score

# XGBoost 모델 학습
model = XGBClassifier()
model.fit(X_train, y_train)

# 예측 및 평가
y_pred = model.predict(X_test)
print(f'Accuracy: {accuracy_score(y_test, y_pred)}')
  •  스태킹(Stacking)
    • 여러 모델의 예측 결과를 메타 모델에 입력으로 사용하여 최종 예측 도출
     
from sklearn.ensemble import StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC

# 기본 모델 설정
estimators = [
    ('rf', RandomForestClassifier(n_estimators=100)),
    ('xgb', XGBClassifier())
]

# 스태킹 모델 설정
model = StackingClassifier(estimators=estimators, final_estimator=LogisticRegression())

# 모델 학습
model.fit(X_train, y_train)

# 예측 및 평가
y_pred = model.predict(X_test)
print(f'Accuracy: {accuracy_score(y_test, y_pred)}')

 

4. 데이터 증강

  • 데이터 증강 개념
    • 데이터 증강을 통해 학습 데이터 확장 및 다양성 증가
    • 이미지 데이터에서의 증강 기법: 회전, 이동, 색상 변화 등
     
from torchvision import transforms
from torchvision.datasets import CIFAR10
from torch.utils.data import DataLoader

# 데이터 증강 변환
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(10),
    transforms.ToTensor(),
])

# CIFAR-10 데이터셋 로드
train_dataset = CIFAR10(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 데이터 로더 사용 예시
for images, labels in train_loader:
    # 이미지 및 레이블 처리
    pass

 

5. 프로젝트 설명 및 진행

  • 프로젝트 개요
    • 모델 성능 향상을 위한 실전 프로젝트 수행
    • 하이퍼파라미터 튜닝, 앙상블 기법, 데이터 증강을 활용하여 성능 최적화
  • 데이터셋 선택
    • Kaggle 또는 기타 오픈 데이터셋에서 프로젝트 데이터셋 선택
    • 예시: CIFAR-10, Dogs vs. Cats, etc.
  • 프로젝트 단계
    • 데이터 전처리 및 준비
    • 모델 설계 및 구현
    • 하이퍼파라미터 튜닝 및 앙상블 기법 적용
    • 모델 훈련 및 검증
    • 성능 평가 및 결과 분석

6. 프로젝트 예시

  • 예시 프로젝트: CIFAR-10 이미지 분류
    • 데이터셋 로드 및 전처리
    • 하이퍼파라미터 튜닝, 앙상블 기법 및 데이터 증강 적용
     
import torch
import torchvision.transforms as transforms
import torchvision.datasets as datasets
import torchvision.models as models
import torch.optim as optim
import torch.nn as nn
from torch.utils.data import DataLoader

# 데이터 전처리 변환
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(10),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# CIFAR-10 데이터셋 로드
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
val_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)

# Pretrained ResNet 모델 로드 및 수정
model = models.resnet18(pretrained=True)
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10)

# 모델 학습
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)

# 학습 루프
num_epochs = 25
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

    scheduler.step()  # 학습률 갱신
    val_loss = evaluate_model(model, val_loader)  # 검증 손실 계산

    print(f'Epoch {epoch+1}, Loss: {running_loss/len(train_loader)}, Val Loss: {val_loss}, Learning Rate: {scheduler.get_last_lr()}')

# 모델 평가
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in val_loader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy: {100 * correct / total}%')

 

7. 프로젝트 발표 및 코드 리뷰

  • 프로젝트 발표
    • 각 그룹 또는 개인은 프로젝트 결과 발표
    • 모델 설계, 훈련 과정, 성능 평가 결과 등을 공유
  • 코드 리뷰 및 피드백
    • 각 그룹의 코드를 리뷰하고 피드백 제공
    • 개선할 점 및 좋은 점 공유

8. 실습 및 과제

  • 실습 과제
    • 하이퍼파라미터 튜닝, 앙상블 기법 및 데이터 증강을 적용한 모델 학습
    • 모델 성능 향상 후 결과 분석
     
# 실습 과제 예시
import torch
import torchvision.transforms as transforms
import torchvision.datasets as datasets
import torchvision.models as models
import torch.optim as optim
import torch.nn as nn
from torch.utils.data import DataLoader
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

# 데이터 전처리 변환
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.RandomHorizontalFlip(),
    transforms.RandomRotation(10),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])

# CIFAR-10 데이터셋 로드
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
val_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)

# Pretrained ResNet 모델 로드 및 수정
model = models.resnet18(pretrained=True)
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10)

# 모델 학습
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=10, gamma=0.1)

# 학습 루프
num_epochs = 25
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

    scheduler.step()  # 학습률 갱신
    val_loss = evaluate_model(model, val_loader)  # 검증 손실 계산

    print(f'Epoch {epoch+1}, Loss: {running_loss/len(train_loader)}, Val Loss: {val_loss}, Learning Rate: {scheduler.get_last_lr()}')

# 모델 평가
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in val_loader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy: {100 * correct / total}%')
  • 과제 제출
    • Jupyter Notebook 파일 및 프로젝트 코드 제출
    • 제출 기한: 다음 강의 시작 전까지

 

반응형