🎨 GAN, 넌 누구니?

⚔️ 위조범과 감정사의 대결

🧮 수학적 원리: 어렵지만 알아두면 멋있어

🏛️ 건축 설계에서의 실제 적용

🔬 다양한 GAN 변형들

⚙️ 실제 구현: 코드로 들여다보기

import tensorflow as tf
from tensorflow.keras import layers

def build_generator(latent_dim):
    model = tf.keras.Sequential([
        # 입력: 랜덤 노이즈 벡터
        layers.Dense(256, input_dim=latent_dim),
        layers.LeakyReLU(alpha=0.2),
        layers.BatchNormalization(),
        
        layers.Dense(512),
        layers.LeakyReLU(alpha=0.2),
        layers.BatchNormalization(),
        
        layers.Dense(1024),
        layers.LeakyReLU(alpha=0.2),
        layers.BatchNormalization(),
        
        # 출력: 건축 도면 이미지 (예: 256x256 픽셀)
        layers.Dense(256 * 256 * 1, activation='tanh'),
        layers.Reshape((256, 256, 1))
    ])
    
    return model

def build_discriminator(img_shape):
    model = tf.keras.Sequential([
        # 입력: 건축 도면 이미지
        layers.Flatten(input_shape=img_shape),
        
        layers.Dense(1024),
        layers.LeakyReLU(alpha=0.2),
        layers.Dropout(0.3),
        
        layers.Dense(512),
        layers.LeakyReLU(alpha=0.2),
        layers.Dropout(0.3),
        
        layers.Dense(256),
        layers.LeakyReLU(alpha=0.2),
        layers.Dropout(0.3),
        
        # 출력: 진짜일 확률 (0~1)
        layers.Dense(1, activation='sigmoid')
    ])
    
    return model

def train_gan(generator, discriminator, dataset, epochs, batch_size):
    # 옵티마이저 설정
    gen_optimizer = tf.keras.optimizers.Adam(0.0002, beta_1=0.5)
    disc_optimizer = tf.keras.optimizers.Adam(0.0002, beta_1=0.5)
    
    for epoch in range(epochs):
        for real_images in dataset:
            batch_size = real_images.shape[0]
            
            # 1. 판별자 학습
            noise = tf.random.normal([batch_size, latent_dim])
            fake_images = generator(noise, training=False)
            
            with tf.GradientTape() as disc_tape:
                real_output = discriminator(real_images, training=True)
                fake_output = discriminator(fake_images, training=True)
                
                # 판별자 손실: 진짜는 1로, 가짜는 0으로 판별하도록
                disc_loss = discriminator_loss(real_output, fake_output)
            
            disc_gradients = disc_tape.gradient(disc_loss, 
                                                discriminator.trainable_variables)
            disc_optimizer.apply_gradients(zip(disc_gradients, 
                                              discriminator.trainable_variables))
            
            # 2. 생성자 학습
            noise = tf.random.normal([batch_size, latent_dim])
            
            with tf.GradientTape() as gen_tape:
                fake_images = generator(noise, training=True)
                fake_output = discriminator(fake_images, training=False)
                
                # 생성자 손실: 판별자를 속이도록 (가짜를 진짜로 판별하게)
                gen_loss = generator_loss(fake_output)
            
            gen_gradients = gen_tape.gradient(gen_loss, 
                                             generator.trainable_variables)
            gen_optimizer.apply_gradients(zip(gen_gradients, 
                                             generator.trainable_variables))
        
        print(f"Epoch {epoch+1}/{epochs}, D Loss: {disc_loss:.4f}, G Loss: {gen_loss:.4f}")

🎨 실전 활용 사례들

🚧 한계와 도전 과제

🔮 미래 전망: 건축의 미래는?

💻 직접 시작해보기: 초보자 가이드

# 필요한 라이브러리 설치
pip install tensorflow
pip install keras
pip install numpy
pip install matplotlib
pip install opencv-python

# GPU 사용을 위한 CUDA 설정 (선택사항, 하지만 강력 추천!)
# NVIDIA GPU가 있다면 학습 속도가 10-100배 빨라져!

🎓 심화 주제: 더 깊이 들어가기

🌐 실제 산업에서의 활용

🤔 윤리적 고려사항

🎯 실전 프로젝트: 단계별 가이드

import requests
from bs4 import BeautifulSoup
import cv2
import numpy as np

# 온라인에서 평면도 이미지 크롤링
# (저작권 주의! 교육 목적으로만 사용)

def collect_floor_plans(num_images=1000):
    images = []
    labels = []
    
    # 여기에 크롤링 코드
    # 실제로는 공개 데이터셋을 사용하는 게 좋아
    
    return images, labels

# 데이터 전처리
def preprocess_image(img):
    # 크기 조정
    img = cv2.resize(img, (256, 256))
    
    # 정규화 (-1 ~ 1)
    img = (img - 127.5) / 127.5
    
    return img

import tensorflow as tf
from tensorflow.keras import layers

# 조건부 생성자
def build_conditional_generator(latent_dim, num_conditions):
    # 노이즈 입력
    noise_input = layers.Input(shape=(latent_dim,))
    
    # 조건 입력 (방 개수, 면적 등)
    condition_input = layers.Input(shape=(num_conditions,))
    
    # 두 입력을 결합
    combined = layers.Concatenate()([noise_input, condition_input])
    
    # 네트워크 구조
    x = layers.Dense(256)(combined)
    x = layers.LeakyReLU(0.2)(x)
    x = layers.BatchNormalization()(x)
    
    x = layers.Dense(512)(x)
    x = layers.LeakyReLU(0.2)(x)
    x = layers.BatchNormalization()(x)
    
    x = layers.Dense(1024)(x)
    x = layers.LeakyReLU(0.2)(x)
    x = layers.BatchNormalization()(x)
    
    # 이미지 생성
    x = layers.Dense(256 * 256 * 1, activation='tanh')(x)
    output = layers.Reshape((256, 256, 1))(x)
    
    model = tf.keras.Model([noise_input, condition_input], output)
    return model

# 조건부 판별자
def build_conditional_discriminator(img_shape, num_conditions):
    # 이미지 입력
    img_input = layers.Input(shape=img_shape)
    
    # 조건 입력
    condition_input = layers.Input(shape=(num_conditions,))
    
    # 이미지 처리
    x = layers.Flatten()(img_input)
    
    # 조건과 결합
    x = layers.Concatenate()([x, condition_input])
    
    # 네트워크 구조
    x = layers.Dense(1024)(x)
    x = layers.LeakyReLU(0.2)(x)
    x = layers.Dropout(0.3)(x)
    
    x = layers.Dense(512)(x)
    x = layers.LeakyReLU(0.2)(x)
    x = layers.Dropout(0.3)(x)
    
    x = layers.Dense(256)(x)
    x = layers.LeakyReLU(0.2)(x)
    x = layers.Dropout(0.3)(x)
    
    # 진위 판별
    output = layers.Dense(1, activation='sigmoid')(x)
    
    model = tf.keras.Model([img_input, condition_input], output)
    return model

# 하이퍼파라미터 설정
LATENT_DIM = 100
NUM_CONDITIONS = 3  # 방 개수, 면적, 방향
BATCH_SIZE = 32
EPOCHS = 10000
LEARNING_RATE = 0.0002

# 모델 생성
generator = build_conditional_generator(LATENT_DIM, NUM_CONDITIONS)
discriminator = build_conditional_discriminator((256, 256, 1), NUM_CONDITIONS)

# 옵티마이저
gen_optimizer = tf.keras.optimizers.Adam(LEARNING_RATE, beta_1=0.5)
disc_optimizer = tf.keras.optimizers.Adam(LEARNING_RATE, beta_1=0.5)

# 학습 루프
for epoch in range(EPOCHS):
    for batch in dataset:
        real_images, conditions = batch
        batch_size = real_images.shape[0]
        
        # 판별자 학습
        noise = tf.random.normal([batch_size, LATENT_DIM])
        fake_images = generator([noise, conditions], training=False)
        
        with tf.GradientTape() as disc_tape:
            real_output = discriminator([real_images, conditions], training=True)
            fake_output = discriminator([fake_images, conditions], training=True)
            
            disc_loss = discriminator_loss(real_output, fake_output)
        
        disc_gradients = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        disc_optimizer.apply_gradients(zip(disc_gradients, discriminator.trainable_variables))
        
        # 생성자 학습
        noise = tf.random.normal([batch_size, LATENT_DIM])
        
        with tf.GradientTape() as gen_tape:
            fake_images = generator([noise, conditions], training=True)
            fake_output = discriminator([fake_images, conditions], training=False)
            
            gen_loss = generator_loss(fake_output)
        
        gen_gradients = gen_tape.gradient(gen_loss, generator.trainable_variables)
        gen_optimizer.apply_gradients(zip(gen_gradients, generator.trainable_variables))
    
    # 100 에포크마다 결과 저장
    if epoch % 100 == 0:
        save_generated_images(generator, epoch)
        print(f"Epoch {epoch}: D Loss = {disc_loss:.4f}, G Loss = {gen_loss:.4f}")

# 생성 품질 평가
def evaluate_quality(generator, test_conditions):
    # FID (Frechet Inception Distance) 계산
    # 생성된 이미지와 실제 이미지의 분포 차이를 측정
    
    real_images = load_real_images()
    fake_images = generate_fake_images(generator, test_conditions)
    
    fid_score = calculate_fid(real_images, fake_images)
    print(f"FID Score: {fid_score}")
    
    # 낮을수록 좋아! (0에 가까울수록 실제와 유사)
    
    return fid_score

# 다양성 평가
def evaluate_diversity(generator, num_samples=100):
    # 같은 조건으로 여러 번 생성해서 다양성 체크
    
    condition = [3, 100, 0]  # 3방, 100㎡, 남향
    images = []
    
    for _ in range(num_samples):
        noise = tf.random.normal([1, LATENT_DIM])
        img = generator([noise, [condition]], training=False)
        images.append(img)
    
    # 이미지들 간의 차이 계산
    diversity_score = calculate_diversity(images)
    print(f"Diversity Score: {diversity_score}")
    
    return diversity_score

🔮 최신 연구 동향

🎓 학습 로드맵

🎬 마무리하며