pytorch-8 앙상블

1. 앙상블

앙상블은 여러개의 개별 모델을 결합하여 과적합을 감소시키고 성능을 촉진하는 방법이다. 

 

2. bagging

배깅 앙상블은 bootstrap aggregating의 약자로 bootstrap의 집합을 의미한다. input data를 여러개의 bootstrap으로 쪼개서 개별 학습한 뒤 결합하여 최종 모델을 구축하는 방법이다.   

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from sklearn.metrics import accuracy_score

device = torch.device("cuda" if torch.cuda.is_available() else 'cpu')

모듈을 불러오고 데이터를 설정한다.

class CNN(nn.Module) : 
    def __init__(self) : 
        super(CNN, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2),
            nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=2,stride=2)
        )
        
        self.fc = nn.Linear(32 * 8 * 8 , 10)
        
    def forward(self, x) :
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        
        return x

학습 클래스를 구성한다.

train_transform = transforms.Compose([
    transforms.Resize((32,32)),
    transforms.RandomHorizontalFlip(),
    transforms.RandomVerticalFlip(),
    transforms.AutoAugment(),
    transforms.ToTensor(),
    transforms.Normalize((0.5,0.5,0.5), (0.3,0.3,0.3))
])

test_transform = transforms.Compose([
    transforms.Resize((32,32)),
    transforms.ToTensor(),
    transforms.Normalize((0.5,0.5,0.5), (0.3,0.3,0.3))
])

train_dataset = datasets.CIFAR10(root="./data", train=True, download=True, transform=train_transform)
test_dataset = datasets.CIFAR10(root="./data", train=False, download=True, transform=test_transform)

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)

변형 모델을 구성하고 학습 데이터와 테스트 데이터를 잘라준다.

num_models = 5
models = [CNN().to(device) for _ in range(num_models)]

criterion = nn.CrossEntropyLoss()
optimizers = [optim.AdamW(model.parameters(), lr=0.001) for model in models]

cnn 클래스를 기반으로 5개의 모델을 생성하고 손실함수와 옵티마이저를 설정한다.

num_epochs = 2 
for epoch in range(num_epochs) : 
    for model, optimizer in zip(models, optimizers) : 
        model.train()
        for images , labels in train_loader : 
            images = images.to(device)
            labels = labels.to(device)
            
            optimizer.zero_grad()
            
            outputs = model(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            
    for model in models : 
        model.eval()
        
    predictions = []
    targets = []
    with torch.no_grad() : 
        for images, labels in test_loader : 
            images = images.to(device)
            labels = labels.to(device)
            
            ensemble_outputs = torch.zeros((images.size(0), 10)).to(device)
            for model in models : 
                outputs = model(images)
                ensemble_outputs += outputs/num_models
                
                _, pred = torch.max(ensemble_outputs.data, 1)
            
            
            predictions.extend(pred.cpu().numpy())
            targets.extend(labels.cpu().numpy())
            
    acc = accuracy_score(targets, predictions)
    print(f"Epoch {epoch+1}/{num_epochs}, ACC {acc}")

5개의 모델을 2회씩 학습을 진행하고 앙상블 결과에서 가장 높은 확률 값을 예측값으로 선택한다. 예측값과 실제 라벨간의 정확도를 출력하여 확인해본다.

3. boosting

부스팅 앙상블은 배깅 앙상블과 똑같은 구조로 학습하지만 순서에 차이가 있다. 배깅은 병렬적으로 학습되는 반변 부스팅은 각 bootstrap이 순차적으로 학습되며 가중치를 가지고 다음 학습에 영향을 미친다. 따라서 부스팅은 배깅에 비해 성능을 개선하거나 과적합의 위험이 상대적으로 적을 때 사용할 수 있다.

4. stacking

스태킹 앙상블은 개별 모델을 통해 학습을 진행하고 모델을 합친 후 다시 학습을 진행하는 방법이다. 즉 학습이 크게 두 번 발생하며 스태킹은 여러개의 레이어가 쌓여서 앙상블을 구성하기 때문에 성능이 높아지며 과적합될 수 있다.

5. voting

보팅 앙상블은 다수의 모델이 예측한 결과를 hard voting(예측 결과값 중 가장 빈번하게 발생한 값), soft voting(예측 결과값 중 확률의 평균값으로 결정) 같은 방법으로 결과값을 발생시키는 방법이다.