[NLP] AutoEncoder (오토인코더)

NLP를 오랜만에 공부해보다 AutoEncoder에 대한 내용이 없는거 같아 한번 설명해 보겠습니다.

오토인코더(Autoencoder)란?

AutoEncoder(오토인코더)는 인공신경망을 기반으로 한 비지도 학습 모델로, 주어진 데이터의 효율적인 표현을 학습하는 데 중점을 둡니다. 이는 데이터를 압축하고 차원을 축소하거나, 노이즈를 제거하고 이상 탐지와 같은 다양한 응용 분야에 사용됩니다.

 

오토인코더(Autoencoder)의 작동 원리

오토인코더는 입력 데이터를 압축하여 잠재 공간(latent space)이라는 저차원 표현으로 변환한 다음, 이를 다시 원래의 데이터로 복원하는 과정을 통해 학습합니다. 이러한 과정은 주로 다음 두 가지 주요 구성 요소로 이루어집니다.

https://towardsdatascience.com/applied-deep-learning-part-3-autoencoders-1c083af4d798

1. 인코더(Encoder): 입력 데이터를 저차원 잠재 공간 벡터로 변환하는 과정입니다. 인코더는 입력층에서 시작하여 여러 개의 은닉층을 거쳐, 최종적으로 잠재 공간 벡터를 출력합니다. 이 과정에서 입력 데이터의 중요한 특징을 저차원으로 압축하게 됩니다.
2. 디코더(Decoder): 인코더에서 생성된 저차원 잠재 공간 벡터를 다시 원래의 데이터로 복원하는 과정입니다. 디코더는 잠재 공간 표현에서 시작하여 여러 층의 신경망을 통해 출력층까지 도달합니다. 디코더의 목표는 입력 데이터와 최대한 비슷한 출력을 생성하는 것입니다.

---

오토인코더(Autoencoder)의 유형

오토인코더는 그 구조와 목적에 따라 다양한 유형으로 나뉩니다.

1. 기본 오토인코더 (Basic Autoencoder): 가장 기본적인 형태로, 하나의 인코더와 하나의 디코더로 구성됩니다. 주로 간단한 데이터 표현 학습에 사용됩니다.
2. 딥 오토인코더 (Deep Autoencoder): 여러 개의 은닉층을 가지는 심층 신경망 구조로, 복잡한 데이터의 특징을 더 깊이 학습할 수 있습니다. 이는 데이터의 더 정교한 표현을 가능하게 합니다.
3. 희소 오토인코더 (Sparse Autoencoder): 잠재 공간 벡터의 요소 중 일부가 0이 되도록 제약을 가하여, 데이터의 중요한 특징을 더 잘 학습할 수 있도록 합니다. 이는 고차원 데이터에서 중요한 특징만을 추출하는 데 유용합니다.
4. 변이형 오토인코더 (Variational Autoencoder, VAE): 잠재 공간을 확률 분포로 모델링하여, 데이터의 잠재 구조를 더 잘 파악할 수 있게 합니다. 이는 새로운 데이터를 생성하는 데에도 사용되며, 생성 모델로도 많이 활용됩니다.
5. 잡음 제거 오토인코더 (Denoising Autoencoder): 입력 데이터에 노이즈를 추가한 후, 이를 원래의 깨끗한 데이터로 복원하는 방법을 학습합니다. 이를 통해 데이터의 노이즈를 제거하고 더 강인한 특징을 학습할 수 있습니다.

---

오토인코더(Autoencoder)의 응용분야

오토인코더는 다양한 분야에서 활용됩니다:

• 데이터 압축 (Data Compression): 입력 데이터를 저차원 벡터로 압축하여 저장 공간을 절약하거나 전송 시간을 단축할 수 있습니다.
• 차원 축소 (Dimensionality Reduction): 고차원 데이터를 저차원으로 축소하여 시각화하거나, 다른 머신러닝 알고리즘의 성능을 향상시킬 수 있습니다.
• 노이즈 제거 (Noise Reduction): 잡음 제거 오토인코더를 사용해 데이터의 노이즈를 제거하고 깨끗한 데이터를 복원할 수 있습니다.
• 이상 탐지 (Anomaly Detection): 정상 데이터로 학습한 오토인코더가 이상 데이터를 복원하지 못하는 특성을 이용해, 비정상 데이터를 탐지할 수 있습니다.
• 생성 모델 (Generative Model): 변이형 오토인코더를 사용해 새로운 데이터를 생성할 수 있으며, 이는 이미지 생성, 데이터 증강 등에 활용됩니다.

---

오토인코더(Autoencoder)의 장, 단점

장점

• 비지도 학습: 레이블이 없는 데이터로 학습이 가능하여 다양한 상황에서 적용할 수 있습니다.
• 다양한 응용 분야: 데이터 압축, 노이즈 제거, 이상 탐지 등 여러 응용 분야에 사용될 수 있습니다.
• 데이터의 중요한 특징 파악: 학습된 잠재 공간 벡터를 분석하여 데이터의 중요한 특징을 이해할 수 있습니다.

단점

• 복원 정확도: 복원된 데이터가 원본 데이터와 완전히 일치하지 않을 수 있습니다.
• 복잡한 데이터 처리 한계: 매우 복잡한 데이터에 대해서는 성능이 제한될 수 있습니다.
• 과적합 위험: 적절한 정규화가 없을 경우 과적합이 발생할 수 있으며, 이는 일반화 성능을 저하시킬 수 있습니다.

---

오토인코더(Autoencoder) Example Code

MNIST Dataset을 예시 & PyTorch Framework를 사용하였습니다.

import torch  # PyTorch 라이브러리 임포트
import torch.nn as nn  # 신경망 모듈 임포트
import torch.optim as optim  # 최적화 알고리즘 모듈 임포트
from torchvision import datasets, transforms  # 데이터셋과 데이터 전처리 변환 모듈 임포트
import matplotlib.pyplot as plt  # 데이터 시각화를 위한 matplotlib 임포트

# 데이터셋 로드 및 전처리
transform = transforms.Compose([
    transforms.ToTensor(),  # 데이터를 텐서로 변환 (이미지를 PyTorch 텐서로 변환)
    transforms.Normalize((0.5,), (0.5,))  # 데이터를 정규화 (평균 0.5, 표준편차 0.5로 정규화)
])

# MNIST 훈련 데이터셋 로드 (손글씨 숫자 데이터)
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
# 훈련 데이터 로더 정의 (데이터셋을 배치 크기 64로, 무작위로 섞어서 로드)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)

# MNIST 테스트 데이터셋 로드
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
# 테스트 데이터 로더 정의 (데이터셋을 배치 크기 64로, 순차적으로 로드)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)

Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
Failed to download (trying next):
HTTP Error 403: Forbidden

Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz
Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz
100%|██████████| 9912422/9912422 [00:11<00:00, 899702.19it/s] 
Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw

Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
Failed to download (trying next):
HTTP Error 403: Forbidden

Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz
Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz
100%|██████████| 28881/28881 [00:00<00:00, 129719.63it/s]
Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw

Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
Failed to download (trying next):
HTTP Error 403: Forbidden

Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz
Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz
100%|██████████| 1648877/1648877 [00:01<00:00, 1244815.31it/s]
Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw

Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
Failed to download (trying next):
HTTP Error 403: Forbidden

Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz
Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz
100%|██████████| 4542/4542 [00:00<00:00, 8819689.24it/s]Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw

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

# 오토인코더(Autoencoder) 클래스 정의, nn.Module을 상속받음
class Autoencoder(nn.Module):
    def __init__(self):
        super(Autoencoder, self).__init__()  # nn.Module의 초기화 함수 호출

        # 인코더 정의: 입력 이미지를 저차원 잠재 공간 벡터로 압축
        self.encoder = nn.Sequential(
            nn.Linear(28 * 28, 128),  # 입력 이미지 크기 28x28을 128차원으로 변환
            nn.ReLU(),  # 활성화 함수로 ReLU 사용
            nn.Linear(128, 64),  # 128차원에서 64차원으로 축소
            nn.ReLU(),  # 활성화 함수로 ReLU 사용
            nn.Linear(64, 32)  # 64차원에서 32차원으로 축소
        )

        # 디코더 정의: 잠재 공간 벡터를 원래 이미지 크기로 복원
        self.decoder = nn.Sequential(
            nn.Linear(32, 64),  # 32차원에서 64차원으로 확장
            nn.ReLU(),  # 활성화 함수로 ReLU 사용
            nn.Linear(64, 128),  # 64차원에서 128차원으로 확장
            nn.ReLU(),  # 활성화 함수로 ReLU 사용
            nn.Linear(128, 28 * 28),  # 128차원에서 28x28 크기의 원래 이미지로 복원
            nn.Tanh()  # 출력 값을 -1과 1 사이로 정규화
        )

    def forward(self, x):
        # 순전파 함수 정의: 인코더 -> 노이즈 추가 -> 디코더
        x = self.encoder(self.noise(x))  # 입력 데이터에 노이즈를 추가한 후 인코더 통과
        x = self.decoder(x)  # 디코더를 통해 원래 이미지 크기로 복원
        return x  # 복원된 이미지 반환

    def noise(self, x, noise_factor=0.5):
        # 노이즈 추가 함수: 입력 데이터에 노이즈를 추가하여 더 강인한 학습을 유도
        noise = noise_factor * torch.randn_like(x)  # 입력 데이터와 같은 크기의 랜덤 노이즈 생성
        x_noisy = x + noise  # 원본 데이터에 노이즈 추가
        return x_noisy  # 노이즈가 추가된 데이터 반환

# 모델 초기화
model = Autoencoder().to(device)  # Autoencoder 모델 인스턴스 생성 후 GPU/CPU로 이동
criterion = nn.MSELoss()  # 손실 함수로 평균 제곱 오차(MSE) 사용
optimizer = optim.Adam(model.parameters(), lr=0.001)  # 옵티마이저로 Adam 사용, 학습률 0.001로 설정

print(model)

Autoencoder(
  (encoder): Sequential(
    (0): Linear(in_features=784, out_features=128, bias=True)
    (1): ReLU()
    (2): Linear(in_features=128, out_features=64, bias=True)
    (3): ReLU()
    (4): Linear(in_features=64, out_features=32, bias=True)
  )
  (decoder): Sequential(
    (0): Linear(in_features=32, out_features=64, bias=True)
    (1): ReLU()
    (2): Linear(in_features=64, out_features=128, bias=True)
    (3): ReLU()
    (4): Linear(in_features=128, out_features=784, bias=True)
    (5): Tanh()
  )
)

num_epochs = 20  # 총 학습 에폭 수 설정

# 학습 루프 시작
for epoch in range(num_epochs):
    for data, _ in train_loader:  # 훈련 데이터셋에서 배치 단위로 데이터를 가져옴
        data = data.view(-1, 28 * 28).to(device)  # 입력 데이터를 28x28 크기의 이미지에서 1차원 벡터로 변환하고, GPU/CPU로 이동

        # 순전파: 입력 데이터를 모델에 통과시켜 출력 생성
        output = model(data)
        loss = criterion(output, data)  # 출력과 원본 데이터 간의 손실(오차)을 계산 (MSE 사용)

        # 역전파: 손실을 기준으로 모델의 가중치를 업데이트
        optimizer.zero_grad()  # 이전 배치의 경사도를 0으로 초기화
        loss.backward()  # 손실에 대한 경사도 계산 (역전파)
        optimizer.step()  # 계산된 경사도를 바탕으로 모델의 가중치를 업데이트

    # 각 에폭이 끝날 때마다 현재 에폭과 손실 값을 출력
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

 

 

# 테스트 데이터셋에서 몇 가지 이미지를 복원하여 시각화
model.eval()  # 모델을 평가 모드로 전환 (드롭아웃, 배치 정규화 등이 비활성화됨)
with torch.no_grad():  # 역전파를 추적하지 않도록 no_grad() 블록 사용
    for data, _ in test_loader:  # 테스트 데이터셋에서 배치 단위로 데이터를 로드
        data = data.view(-1, 28 * 28).to(device)  # 이미지를 1차원 벡터로 변환하고, GPU/CPU로 이동
        output = model(data)  # 모델을 통해 입력 데이터를 복원
        output = output.view(-1, 1, 28, 28).cpu()  # 복원된 데이터를 다시 28x28 크기의 이미지로 변환하고 CPU로 이동
        break  # 첫 번째 배치만 사용하여 복원 결과 확인

# 원본 이미지와 복원된 이미지 시각화
fig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(20, 4))  # 2x10 그리드의 서브플롯 생성

# 첫 번째 행에 원본 이미지, 두 번째 행에 복원된 이미지 시각화
for images, row in zip([data.view(-1, 1, 28, 28).cpu(), output], axes):  # 원본과 복원된 이미지를 각각 행에 할당
    for img, ax in zip(images, row):  # 각 이미지와 축(axis)을 순차적으로 가져옴
        ax.imshow(img.numpy().squeeze(), cmap='gray')  # 이미지를 그레이스케일로 시각화
        ax.get_xaxis().set_visible(False)  # x축 숨김
        ax.get_yaxis().set_visible(False)  # y축 숨김

plt.show()  # 시각화된 결과를 화면에 출력

Epoch [1/20], Loss: 0.1157
Epoch [2/20], Loss: 0.0861
Epoch [3/20], Loss: 0.0710
Epoch [4/20], Loss: 0.0640
Epoch [5/20], Loss: 0.0600
Epoch [6/20], Loss: 0.0513
Epoch [7/20], Loss: 0.0536
Epoch [8/20], Loss: 0.0501
Epoch [9/20], Loss: 0.0538
Epoch [10/20], Loss: 0.0533
Epoch [11/20], Loss: 0.0480
Epoch [12/20], Loss: 0.0542
Epoch [13/20], Loss: 0.0482
Epoch [14/20], Loss: 0.0386
Epoch [15/20], Loss: 0.0453
Epoch [16/20], Loss: 0.0455
Epoch [17/20], Loss: 0.0428
Epoch [18/20], Loss: 0.0442
Epoch [19/20], Loss: 0.0436
Epoch [20/20], Loss: 0.0414

# 테스트 데이터셋에서 몇 가지 이미지를 복원하여 시각화
model.eval()
with torch.no_grad():
    for data, _ in test_loader:
        data = data.view(-1, 28 * 28).to(device)
        output = model(data)
        output = output.view(-1, 1, 28, 28).cpu()
        break

# 원본 이미지와 복원된 이미지 시각화
fig, axes = plt.subplots(nrows=2, ncols=10, sharex=True, sharey=True, figsize=(20, 4))

for images, row in zip([data.view(-1, 1, 28, 28).cpu(), output], axes):
    for img, ax in zip(images, row):
        ax.imshow(img.numpy().squeeze(), cmap='gray')
        ax.get_xaxis().set_visible(False)
        ax.get_yaxis().set_visible(False)

plt.show()