Denoising AutoEncoder(DAE, Multi-DAE)

AutoEncoder 구조

Denoising AutoEncoder 구조

 

실제 데이터는 noise가 낀 데이터일 확률이 높다.

 

따라서 AutoEncoder에 비해 더욱 강건한 모델을 만들고자 input 데이터에 인위적인 noise를 추가하고, 모델이 해당 noise를 제거(denoising)하여 원래 input을 재건할 수 있도록 학습한다.

 

 

Denoising 방법으로는 두 가지가 있다.

1) Gaussian(정규 분포)로 부터 추출한 랜덤 값을 각 pixel에 더해주는 방법

2) Dropout을 이용하는 방법

 

**Denoising AutoEncoder는 input 단계에서 noise를 추가하는 것.

 

import torch.nn as nn
import torch.nn.functional as F
import torch
import numpy as np 

class DAE(nn.Module):
    """
    input : encoder_dims

        encoder = [n_items, dim1, dim2]
        decoder_dims = [dim2, dim1, n_items]
    """
    
    def __init__(self, config, encoder_dims, decoder_dims=None, dropout=0.5): 
        super(DAE, self).__init__()
        self.config = config
        self.encoder_dims = encoder_dims
        if decoder_dims:
            assert decoder_dims[0] == encoder_dims[-1], "In and Out dimensions must equal to each other"
            assert decoder_dims[-1] == encoder_dims[0], "Latent dimension for p- and q- network mismatches."
            self.decoder_dims = decoder_dims
        else:
            self.decoder_dims = encoder_dims[::-1]
            
        self.drop = nn.Dropout(dropout)
        self.encoder = self.build_layers(self.encoder_dims, config['activate_function'])
        self.decoder = self.build_layers(self.decoder_dims, config['activate_function'])
        

    def build_layers(self, dims, activate_function = 'ReLU'):
        """
        Helper function to build layers based on the provided dimensions.

        Parameters:
            - dims (list): List of dimensions for the layers.

        Returns:
            - nn.Sequential: Sequential container for the layers.
        """
        layers = []
        for i in range(1, len(dims)):
            layers.append(nn.Linear(dims[i-1], dims[i]))
            if i == len(dims)-1:
                pass
            else:
                if activate_function == 'ReLU':
                    layers.append(nn.ReLU())
                elif activate_function == 'Sigmoid':
                    layers.append(nn.Sigmoid())
                elif activate_function == 'Tanh':
                    layers.append(nn.Tanh())
                else:
                    pass

        return nn.Sequential(*layers)
    
    def add_noise(self, matrix):
        noise = torch.randn(matrix.shape) * 0.5
        matrix = matrix + noise
        return matrix
        
    def forward(self, input):
        if self.config['denoising'] == 'Dropout':
            h = F.normalize(input)
            h = self.drop(h)
            
        elif self.config['denoising'] == 'Gaussian':
            h = self.add_noise(input)
            h = F.normalize(h)

        h = self.encoder(h)
        h = self.decoder(h)
        
        return h
  
    def get_codes(self, x):
        return self.encoder(x)