[Coursera/IBM course #3] Unsupervised Learning in Keras

 

[IBM AI course #3] Deep Learning & Neural Networks with Keras

 

Unsupervised Learning in Keras

Unsupervised Learning

라벨(정답)이 없는 데이터를 기반으로 숨겨진 패턴과 구조를 찾는 기법.

클러스터링, 차원 축소, 이상 탐지 등에 활용

분류	설명	예시
Clustering	비슷한 데이터끼리 그룹(클러스터)로 나누기	K-means, Hierarchical Clustering
Association	변수들 간의 빈번한 관계/규칙 찾기	Apriori, Eclat
Dimensionality Reduction	데이터의 차원 축소를 통해 핵심 특성만 추출	PCA, T-SNE

 

 

오토인코더

Dimensionality Reduction의 PCA와 유사한 역할. 신경망 기반

차원 축소, 특징 학습(feature learning)

입력 = 출력. 입력과 출력 간의 차이를 최소화하며 학습.

인코더: 입력 압축→ 잠재 공간으로 표현

디코더: 잠재 공간 → 원본 입력 복원

 

Autoencoders in Keras

오토인코더는 비지도 학습을 위한 신경망으로

차원 축소, 노이즈 제거, 특징 학습에 사용됨

 

구조

Encoder(인코더): 입력을 압축

Bottleneck(병목): 중요한 특징만 포함

Decoder(디코더): 원래 입력 재구성

 

유형

Basic Autoencoder : 단순한 인코더/디코더

VAE(Variational Autoencoder) : 확률적 요소 포함, 새로운 데이터 생성 가능

Convolutional Autoencoder : CNN 기반 구조, 이미지 처리에 효과적

 

Keras 예제

input_layer = Input(shape=(784,))
encoded = Dense(64, activation='relu')(input_layer)
bottleneck = Dense(32, activation='relu')(encoded)
decoded = Dense(64, activation='relu')(bottleneck) 
output_layer = Dense(784, activation='sigmoid')(decoded) 

autoencoder = Model(input_layer, output_layer) 
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')

 

Diffusion Models

확산 모델은 노이즈 샘플을 반복적으로 정제하여 고품질 데이터를 생성

물리에서의 확산(diffusion) – 입자가 고농도 → 저농도로 퍼지는 과정을 모사

이미지 생성, 이미지 노이즈 제거, 데이터 증강에 사용됨.

 

작동 방식

• Forward process: 원본 데이터에 점진적으로 노이즈 추가 (이미지 → 이미지 + 10% 노이즈 → 30% 노이즈 → ... → 완전한 랜덤 노이즈. 수학적으로는 Markov Process로 모델링)
• Reverse process: 노이즈를 단계적으로 제거해 원본을 복원 (랜덤 노이즈 → 조금 덜한 노이즈 → 거의 복원된 이미지 → 원본 이미지. 신경망이 학습을 통해 모델링하는 부분)

 

Keras 예제

input_layer = Input(shape=(28, 28, 1))
# 인코더 역할
x = Conv2D(16, (3, 3), activation='relu', padding='same')(input_layer) 
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x) 

x = Flatten()(x)
x = Dense(64, activation='relu')(x)  # 	압축된 잠재 표현 학습
x = Dense(28*28*32, activation='relu')(x) # 복원 준비를 위한 정보 확장
x = Reshape((28, 28, 32))(x) # 벡터를 다시 이미지 형태로 변환 (28x28, 채널 32)

# 디코더 역할
x = Conv2DTranspose(32, (3, 3), activation='relu', padding='same')(x)
x = Conv2DTranspose(16, (3, 3), activation='relu', padding='same')(x) 
output_layer = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x)

diffusion_model = Model(input_layer, output_layer
diffusion_model.compile(optimizer='adam', loss='mean_squared_error')

 

GANs (Generative Adversarial Networks)

Generative 모델

GAN은 생성자(generator)와 판별자(discriminator)로 구성된 신경망 구조.

생성자가 진짜 같은 데이터를 만들어 판별자를 속이는 것이 목적

이미지 생성, Image-to-Image Translation (sketch→photo), Text-to-Image, 데이터 증강 등에 사용

구조

생성자(Generator) : 랜덤 노이즈 → 가짜 데이터 생성

판별자(Discriminator) : 진짜/가짜 데이터 판단

 

훈련 과정

생성자와 판별자가 경쟁하며 점점 성능 향상

두 네트워크가 경쟁 (제로섬 게임). 

판별자는 진짜와 가짜를 구분하도록, 생성자는 판별자를 속이도록 학습됨

 

Keras 예제

Discriminator는 독립적으로 먼저 훈련

이후 GAN에서는 Discriminator를 고정(freeze)하고 Generator만 학습

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Generator
# 랜덤 노이즈 입력 → Generator → 생성 이미지
# Discriminator는 freeze 상태
# Discriminator를 속이도록 Generator 가중치 업데이트
def build_generator(): 
    model = Sequential() 
    model.add(Dense(256, input_dim=100)) 
    model.add(LeakyReLU(alpha=0.2)) 
    model.add(BatchNormalization(momentum=0.8)) 
    model.add(Dense(512)) 
    model.add(LeakyReLU(alpha=0.2)) 
    model.add(BatchNormalization(momentum=0.8)) 
    model.add(Dense(1024)) 
    model.add(LeakyReLU(alpha=0.2)) 
    model.add(BatchNormalization(momentum=0.8)) 
    model.add(Dense(28 * 28 * 1, activation='tanh')) 
    model.add(Reshape((28, 28, 1))) 
    return model 

generator = build_generator() 
generator.summary()

# Discriminator
# 이미지 → 진짜/가짜 확률 출력
# 진짜 이미지와 Generator가 만든 가짜 이미지로 훈련
# 진짜/가짜를 잘 구별하도록 Discriminator 가중치 업데이트
def build_discriminator(): 
    model = Sequential() 
    model.add(Flatten(input_shape=(28, 28, 1))) 
    model.add(Dense(512)) 
    model.add(LeakyReLU(alpha=0.2)) 
    model.add(Dense(256)) 
    model.add(LeakyReLU(alpha=0.2)) 
    model.add(Dense(1, activation='sigmoid')) 
    return model 

discriminator = build_discriminator() 
discriminator.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 
discriminator.summary()

def build_gan(generator, discriminator): 
    discriminator.trainable = False 
    gan_input = Input(shape=(100,)) 
    generated_image = generator(gan_input) 
    gan_output = discriminator(generated_image) 
    gan = Model(gan_input, gan_output) 
    gan.compile(loss='binary_crossentropy', optimizer='adam') 
    return gan 

gan = build_gan(generator, discriminator) 
gan.summary()