특화 Autoencoder 아키텍처 실무 구현 및 실험

1. Variational Autoencoder (VAE)

# ... (VAE 코드 참조)

2. Denoising Autoencoder (DAE)

# ... (DAE 코드 참조)

3. Convolutional Autoencoder (CAE)

# ... (CAE 코드 참조)

4. MNIST 데이터셋 연동 예시 (CAE 기준)

from torchvision import datasets, transforms
from torch.utils.data import DataLoader

transform = transforms.Compose([
    transforms.ToTensor(),
])
train_data = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)

model = ConvAutoencoder()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.MSELoss()

for epoch in range(5):
    for img, _ in train_loader:
        optimizer.zero_grad()
        output = model(img)
        loss = criterion(output, img)
        loss.backward()
        optimizer.step()

5. 복원 결과 시각화

import matplotlib.pyplot as plt

model.eval()
with torch.no_grad():
    sample = next(iter(train_loader))[0][:5]  # 5개 이미지
    reconstructed = model(sample)

    fig, axes = plt.subplots(2, 5, figsize=(12, 4))
    for i in range(5):
        axes[0, i].imshow(sample[i][0], cmap='gray')
        axes[0, i].set_title('Original')
        axes[1, i].imshow(reconstructed[i][0], cmap='gray')
        axes[1, i].set_title('Reconstructed')
        for ax in axes[:, i]:
            ax.axis('off')
    plt.tight_layout()
    plt.show()

6. 아키텍처별 성능 비교 표 (예시)

특화 Autoencoder 아키텍처 실무 구현

1. Variational Autoencoder (VAE)

import torch
import torch.nn as nn
import torch.nn.functional as F

class VAE(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(100, 64)
        self.fc21 = nn.Linear(64, 20)  # mu
        self.fc22 = nn.Linear(64, 20)  # logvar
        self.fc3 = nn.Linear(20, 64)
        self.fc4 = nn.Linear(64, 100)

    def encode(self, x):
        h1 = F.relu(self.fc1(x))
        return self.fc21(h1), self.fc22(h1)

    def reparameterize(self, mu, logvar):
        std = torch.exp(0.5*logvar)
        eps = torch.randn_like(std)
        return mu + eps*std

    def decode(self, z):
        h3 = F.relu(self.fc3(z))
        return torch.sigmoid(self.fc4(h3))

    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        return self.decode(z), mu, logvar

def loss_function(recon_x, x, mu, logvar):
    BCE = F.mse_loss(recon_x, x, reduction='sum')
    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
    return BCE + KLD

2. Denoising Autoencoder (DAE)

class DenoisingAutoencoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(100, 64), nn.ReLU(),
            nn.Linear(64, 32), nn.ReLU()
        )
        self.decoder = nn.Sequential(
            nn.Linear(32, 64), nn.ReLU(),
            nn.Linear(64, 100), nn.Sigmoid()
        )

    def forward(self, x):
        z = self.encoder(x)
        return self.decoder(z)

# 노이즈 추가
noisy_X = X + 0.3 * torch.randn_like(X)

# 학습 루프에서 noisy_X 입력, X를 정답으로 사용
for x_batch in loader:
    optimizer.zero_grad()
    output = dae(noisy_X)
    loss = criterion(output, X)
    loss.backward()
    optimizer.step()

3. Convolutional Autoencoder (CAE)

class ConvAutoencoder(nn.Module):
    def __init__(self):
        super().__init__()
        # Encoder
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 16, 3, stride=2, padding=1),  # -> 16x14x14
            nn.ReLU(),
            nn.Conv2d(16, 8, 3, stride=2, padding=1),  # -> 8x7x7
            nn.ReLU()
        )
        # Decoder
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(8, 16, 3, stride=2, padding=1, output_padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(16, 1, 3, stride=2, padding=1, output_padding=1),
            nn.Sigmoid()
        )

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

Autoencoder를 활용한 차원 축소 및 특징 추출

1. 개념

Autoencoder는 입력 데이터를 압축한 뒤 다시 복원하는 비지도 신경망입니다. Encoder → Latent Space → Decoder 구조로 구성됩니다.

2. 적용 방법

3. 실무 코드 (PyTorch)

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

X = torch.rand(1000, 100)

class Autoencoder(nn.Module):
    def __init__(self):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(100, 64), nn.ReLU(),
            nn.Linear(64, 32), nn.ReLU(),
            nn.Linear(32, 10)
        )
        self.decoder = nn.Sequential(
            nn.Linear(10, 32), nn.ReLU(),
            nn.Linear(32, 64), nn.ReLU(),
            nn.Linear(64, 100), nn.Sigmoid()
        )
    def forward(self, x):
        latent = self.encoder(x)
        output = self.decoder(latent)
        return output, latent

model = Autoencoder()
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
loader = DataLoader(TensorDataset(X, X), batch_size=64, shuffle=True)

for epoch in range(20):
    for x_batch, _ in loader:
        optimizer.zero_grad()
        output, _ = model(x_batch)
        loss = criterion(output, x_batch)
        loss.backward()
        optimizer.step()

with torch.no_grad():
    _, latent_features = model(X)

4. 장단점

5. 기대 효과

• 복잡한 고차원 데이터의 효과적 압축
• PCA보다 우수한 비선형 특징 보존
• 클러스터링이나 분류 전 처리로 활용

6. 사용 시기

7. 실무 팁

• BatchNorm, Dropout으로 안정적 학습 유도
• 과적합 방지를 위한 EarlyStopping 활용
• Latent Vector 분포 시각화로 검증

8. 응용 코드: Autoencoder + KMeans

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA

with torch.no_grad():
    _, z = model(X)

kmeans = KMeans(n_clusters=5)
labels = kmeans.fit_predict(z.numpy())

pca = PCA(n_components=2)
z_2d = pca.fit_transform(z.numpy())

plt.scatter(z_2d[:, 0], z_2d[:, 1], c=labels, cmap='rainbow')
plt.title("Autoencoder 기반 KMeans 시각화")
plt.show()

9. 요약

Feature Scaling 완벽 가이드 (AI 전문가용)

1. 정의

Feature Scaling은 다양한 범위를 가진 특성들을 공통된 스케일로 변환하는 전처리 과정입니다.

2. 주요 목적

• 경사하강법 기반 모델 수렴 속도 향상
• 거리 기반 모델 정확도 향상
• 피처 우선순위 왜곡 방지
• PCA/LDA 같은 기법의 전처리

3. 주요 기법

4. 실무 코드 예시 (Scikit-learn)

from sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler, MaxAbsScaler, Normalizer

X = [[1, 100], [2, 300], [3, 600]]

minmax = MinMaxScaler()
X_minmax = minmax.fit_transform(X)

standard = StandardScaler()
X_standard = standard.fit_transform(X)

robust = RobustScaler()
X_robust = robust.fit_transform(X)

maxabs = MaxAbsScaler()
X_maxabs = maxabs.fit_transform(X)

normalizer = Normalizer(norm='l2')
X_l2 = normalizer.fit_transform(X)

5. 장단점 비교

6. 기대 효과

• 수렴 속도 향상
• 모델 안정성 확보
• 정확도 개선
• 하이퍼파라미터 튜닝 효율 증가

7. 적용 시기

• 훈련 직전
• Cross-validation 이전
• 이상치 제거 후
• PCA 등 적용 전

8. 모델별 적합 기법

9. 정리 비교표

10. 실무 팁

• fit은 반드시 훈련셋에만!
• GridSearchCV 사용 시 Pipeline 구성
• 스케일링 종류 변경만으로도 성능 개선 가능
• 이상치가 많다면 Robust부터 시작

📷 CNN을 활용한 이미지 특징 추출 완전 정복

안녕하세요! 오늘은 인공지능에서 이미지 데이터를 처리할 때 핵심 기술인 CNN 기반 이미지 특징 추출에 대해 정리해보려고 합니다. 딥러닝 입문자부터 실무 개발자까지 이해할 수 있도록 이론, 구조, 실무 코드까지 모두 소개하겠습니다.

1. 이미지 특징 추출이란?

이미지는 수많은 픽셀로 구성된 고차원 데이터입니다. 이 데이터를 압축하고 의미 있는 정보(선, 모양, 질감 등)만 추출해서 벡터(특징 벡터)로 표현하는 과정이 특징 추출입니다. 머신러닝/딥러닝 모델의 입력으로 쓰기 위해 반드시 필요합니다.

2. 이미지 특징 추출 방법 종류

• 전통적인 방법: SIFT, HOG, SURF 등
• 딥러닝 기반 방법 (CNN)

3. CNN(Convolutional Neural Network)의 개념

CNN은 이미지 처리에 특화된 구조로, 이미지에서 공간적 패턴(엣지, 모서리, 패턴 등)을 자동으로 학습합니다. Conv Layer와 Pooling Layer를 반복하며 점점 추상적인 특징을 뽑아냅니다.

4. CNN 기반 특징 추출 방법의 종류 및 정의

5. 실무 예제: 사전학습된 ResNet을 활용한 특징 추출

from torchvision import models, transforms
from PIL import Image
import torch
import numpy as np

# 1. 이미지 전처리
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

# 2. 이미지 불러오기
img = Image.open("cat.jpg").convert("RGB")
img_tensor = transform(img).unsqueeze(0)  # 배치 차원 추가

# 3. 모델 로딩 및 특징 추출 (fc 제거)
resnet = models.resnet50(pretrained=True)
feature_extractor = torch.nn.Sequential(*list(resnet.children())[:-1])
feature_extractor.eval()

# 4. 특징 벡터 추출
with torch.no_grad():
    features = feature_extractor(img_tensor)
    features = features.view(features.size(0), -1)  # Flatten
    print("특징 벡터 shape:", features.shape)

6. CNN 특징 추출 방식별 장단점

7. 기타 실무 팁

• ❗ 데이터 정규화: 반드시 학습된 모델에 맞는 평균/표준편차 사용
• 📦 특징 벡터 저장: 벡터를 .npy 등으로 저장 후 별도 분석 추천
• 🧠 클러스터링, 유사도 분석: 추출된 벡터로 군집화나 검색 시스템 구현 가능
• 💡 시각화 도구: t-SNE, PCA 등으로 벡터 분포를 시각화하면 유용함

8. 마무리

CNN은 이미지 데이터를 다룰 때 가장 강력한 도구입니다. 단순한 분류를 넘어서, CNN의 중간 출력값(특징 벡터)을 활용하면 추천 시스템, 검색 엔진, 군집화, 이상탐지 등 다양한 영역으로 확장할 수 있습니다.

오늘 소개한 코드는 실제 프로젝트에서도 그대로 사용할 수 있으며, 다양한 사전학습 모델을 활용해 더 넓은 작업에 응용할 수 있습니다. 다음 글에서는 추출한 특징 벡터를 활용한 유사 이미지 검색 시스템도 다뤄볼게요!

📝 자연어처리 실무 회고록: TF-IDF와 Word2Vec 정복기

안녕하세요! 오늘은 제가 실제 텍스트 분류 프로젝트에서 사용한 TF-IDF와 Word2Vec에 대해 정리해보려 합니다. 처음 자연어처리를 시작할 때 막막했던 기억이 있어, 같은 길을 걷는 분들께 조금이나마 도움이 되길 바라며 이 글을 씁니다.

1. 텍스트 데이터 벡터화란?

텍스트는 숫자가 아니기 때문에 머신러닝 모델이 직접 처리할 수 없습니다. 따라서 단어 또는 문장을 벡터로 표현하는 작업이 필요합니다. 이때 사용하는 대표적인 기법이 바로 TF-IDF와 Word2Vec입니다.

2. 종류

• TF-IDF (Term Frequency-Inverse Document Frequency)
• Word2Vec (단어 임베딩)
  • CBOW (Continuous Bag of Words)
  • Skip-gram

3. 종류별 개념과 원리

🟩 TF-IDF

문서 내 자주 등장하지만 전체 문서에서는 드문 단어에 높은 가중치를 부여하는 방식입니다.

• TF: 단어 빈도
• IDF: 역문서 빈도 (전체 문서에서 드문 단어에 높은 점수)

🟦 Word2Vec

단어를 일정 크기의 밀집된 벡터로 표현하는 임베딩 기법입니다. 문맥 정보를 반영하여 단어 간 의미 유사성을 학습합니다.

• CBOW: 주변 단어로 중심 단어 예측
• Skip-gram: 중심 단어로 주변 단어 예측

4. 기본 코드 예시

TF-IDF

from sklearn.feature_extraction.text import TfidfVectorizer

texts = ["오늘 날씨가 좋다", "내일은 비가 온다"]
tfidf = TfidfVectorizer()
tfidf_matrix = tfidf.fit_transform(texts)
print(tfidf_matrix.toarray())

Word2Vec

from gensim.models import Word2Vec

sentences = [["오늘", "날씨", "좋다"], ["내일", "비", "온다"]]
model = Word2Vec(sentences, vector_size=100, window=5, sg=1, min_count=1)
print(model.wv["날씨"])

5. 실무 적용 경험담

제가 진행한 뉴스 기사 분류 프로젝트에서, 처음에는 TF-IDF를 사용했는데 빠르고 간단하게 성능이 잘 나왔습니다. 하지만 주제 간 단어가 많이 겹칠 경우 구분이 어려웠고, 의미 기반 분류가 필요하다고 판단해 Word2Vec을 도입했습니다.

Word2Vec 도입 후 단어 유사도가 반영되면서 정확도가 6~8% 개선되었습니다. 특히 유사 주제 간 문장을 잘 구분해줘서 놀라웠습니다.

6. 장단점 비교

7. 사용 시기

• TF-IDF: 빠르게 모델을 만들고 싶을 때, 텍스트가 단순할 때
• Word2Vec: 의미 유사성, 문맥이 중요한 태스크일 때

8. 주의사항

• TF-IDF는 단어 빈도가 극단적으로 한쪽에 치우치면 잘 작동하지 않음
• Word2Vec은 말뭉치가 충분히 커야 의미 있는 벡터가 생성됨
• Word2Vec은 반드시 토큰화 + 정제된 데이터에서 학습해야 안정됨

9. 마무리

TF-IDF와 Word2Vec 모두 장단점이 확실하며, 상황에 따라 선택하거나 둘을 조합할 수도 있습니다. 실제로 저는 둘 다 벡터로 만들어 concat해서 DNN에 넣어본 적도 있습니다. 중요한 건 데이터의 성격을 먼저 파악하고 접근하는 것입니다!

도움이 되셨다면 댓글로 여러분의 경험도 공유해주세요 😊

🧠 Feature Interaction 완전 정복: 변수 간 곱, 합 활용

1. 개념

Feature Interaction은 둘 이상의 변수 간의 곱(multiplicative), 합(additive) 등을 통해 새로운 의미 있는 피처를 생성하는 전처리 기법입니다.

2. 원리

• 기존의 독립적인 변수들이 결합되면 모델이 학습하기 어려운 패턴을 더 잘 표현할 수 있게 됩니다.
• 예: 매출 = 가격 × 수량

3. 사용 방법

df['A_B_mul'] = df['A'] * df['B']
df['A_B_add'] = df['A'] + df['B']

4. 사용 시기

• 모델 성능이 더 이상 개선되지 않을 때
• 변수 간 상호작용이 의미가 있을 때 (도메인 지식 활용)
• 트리 기반 모델 또는 DNN 사용 시

5. 기대 효과

• 모델 성능 향상 (정확도, AUC 등)
• 복잡한 관계 학습 가능
• 해석 가능한 피처 제공 가능

6. 코드 기본 예시

import pandas as pd

df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})

df['A_B_mul'] = df['A'] * df['B']
df['A_B_add'] = df['A'] + df['B']
print(df)

7. 실무 적용 예시

df['price'] = [100, 200, 150]
df['quantity'] = [2, 1, 3]
df['total_sales'] = df['price'] * df['quantity']

8. 사용 시 주의사항

• 과도한 피처 수 증가 주의
• 모델 과적합 가능성 존재
• 불필요한 상호작용 생성은 노이즈만 증가시킴

9. 성능 향상 예시

10. PolynomialFeatures 자동 생성

from sklearn.preprocessing import PolynomialFeatures

poly = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False)
features = poly.fit_transform(df)
feature_names = poly.get_feature_names_out(df.columns)

11. FeatureUnion & ColumnTransformer

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler, OneHotEncoder

preprocessor = ColumnTransformer([
  ('num', Pipeline([
      ('poly', PolynomialFeatures(degree=2, interaction_only=True)),
      ('scaler', StandardScaler())
  ]), ['A', 'B']),
  ('cat', OneHotEncoder(), ['category'])
])

12. DeepFM 구조 설명

• FM Layer: 2차 피처 상호작용 자동 학습
• Deep Layer: DNN으로 고차 상호작용 학습
• Shared Embedding 사용으로 효율적 구조

embed_x = self.embedding(x)
fm_output = self.fm(embed_x)
deep_output = self.deep(embed_x.view(x.size(0), -1))
return fm_output + deep_output

✅ 마무리 요약

• 곱, 합 기반 Feature Interaction은 간단하지만 강력한 전처리 방법
• 트리 기반, 딥러닝 기반 모델에서 특히 효과적
• PolynomialFeatures, ColumnTransformer, DeepFM 등 다양한 구현 방식 존재