YOLO 모델을 멀티 GPU(4,5,6,7)로 학습시키려 했으나, 동일한 설정으로 GPU(0,1,2,3)에서는 정상 작동하는데 CUDA Out of Memory 에러가 발생했다.

torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate 50.00 MiB. 
GPU 0 has a total capacty of 10.75 GiB of which 50.69 MiB is free.

원인 분석

1. GPU 메모리 상태 확인

nvidia-smi

실행 결과, GPU 4,5,6,7에 프로세스는 보이지 않지만 메모리가 점유되어 있는 상태였다:

• GPU 4: 9170MB 사용 중
• GPU 5: 8496MB 사용 중 (Utilization 100%)
• GPU 6: 9064MB 사용 중 (Utilization 100%)
• GPU 7: 10254MB 사용 중 (Utilization 100%)

2. 좀비 프로세스 확인

sudo lsof /dev/nvidia4 /dev/nvidia5 /dev/nvidia6 /dev/nvidia7

Python 프로세스들이 GPU 디바이스 파일을 열어놓고 있어서 메모리가 해제되지 않는 상태였다. 이는 이전 학습이 비정상 종료되어 발생한 좀비 프로세스 문제였다.

해결 방법

Step 1: 문제 프로세스 찾기

# GPU 상태 상세 확인
nvidia-smi

# GPU를 사용하는 프로세스 확인
sudo lsof /dev/nvidia4 /dev/nvidia5 /dev/nvidia6 /dev/nvidia7

# Python 프로세스 확인
ps aux | grep python

Step 2: 좀비 프로세스 종료

# 특정 PID 종료 (lsof에서 확인한 PID)
kill -9 [PID1] [PID2] [PID3] [PID4]

# nvidia-smi 프로세스도 종료 (필요시)
sudo kill -9 [nvidia-smi_PID]

# DDP 관련 임시 파일 정리
rm -rf ~/.config/Ultralytics/DDP/_temp_*

Step 3: GPU 리셋 시도

# 개별 GPU 리셋 (성공할 때까지 반복)
sudo nvidia-smi --gpu-reset -i 4
sudo nvidia-smi --gpu-reset -i 5
sudo nvidia-smi --gpu-reset -i 6
sudo nvidia-smi --gpu-reset -i 7

만약 "GPU is currently in use" 에러가 계속 나타나면:

# 숨겨진 프로세스 강제 종료
sudo fuser -k /dev/nvidia4
sudo fuser -k /dev/nvidia5
sudo fuser -k /dev/nvidia6
sudo fuser -k /dev/nvidia7

Step 4: 상태 확인

nvidia-smi

모든 GPU가 6MB 정도만 사용하는 깨끗한 상태가 되면 성공!

두 개 모델 동시 학습 설정

Model 1 (GPU 0,1,2,3)

# train_model1.py
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "0,1,2,3"

from ultralytics import YOLO
model = YOLO('yolov8s.pt')

results = model.train(
    data='dataset1/data.yaml',
    imgsz=1280,
    batch=16,
    epochs=1000,
    optimizer='AdamW',
    workers=2,
    cache='disk',
    mosaic=0,
    lr0=0.01,
    patience=300,
    plots=True,
    rect=False,
    project='runs/model1',  # 별도 폴더
    name='train'
)

Model 2 (GPU 4,5,6,7)

# train_model2.py
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "4,5,6,7"

from ultralytics import YOLO
model = YOLO('yolov8s.pt')

results = model.train(
    data='dataset2/data.yaml',
    imgsz=1280,
    batch=16,
    epochs=1000,
    optimizer='AdamW',
    workers=2,
    cache='disk',
    mosaic=0,
    lr0=0.01,
    patience=300,
    plots=True,
    rect=False,
    project='runs/model2',  # 별도 폴더
    name='train'
)

동시 실행

# Terminal 1
python train_model1.py

# Terminal 2 (또는 tmux/screen 사용)
python train_model2.py

예방 조치

• 정기적인 캐시 정리

# cron으로 매일 실행
0 3 * * * rm -rf ~/.config/Ultralytics/DDP/_temp_* && rm -rf ~/.cache/torch/

: $x_T \rightarrow x_{T-1} \rightarrow \cdots \rightarrow x_0$ : 매 단계 $x_{t-1}$는 $x_{t}$만 보고 노이즈를 제거하며 복원

1. 들어가며

기존의 GAN(Generative Adversarial Network) 기반 방법들은 사용자의 입력과 사실적 이미지 간 균형을 유지하는 데 어려움이 있었고, 매번 새로운 데이터 수집 및 학습 과정이 필요했다. 이에 대한 대안으로 등장한 것이 바로 SDEdit(Stochastic Differential Editing)이다.

2. SDEdit란?

SDEdit는 확률적 미분 방정식(SDE, Stochastic Differential Equation)을 활용한 이미지 생성 및 편집 방법으로, 확산(diffusion) 모델의 원리를 기반으로 한다. 사용자의 입력(예: 간단한 색상 스트로크, 이미지 패치 등)을 받아 이 입력에 가우시안 잡음을 추가한 후, 이를 다시 제거하는 과정을 반복하여 현실적이고 사용자의 의도에 충실한 이미지를 생성한다.

기존 방식과의 차별점:

• 조건부 GAN(Conditional GAN): 매번 새로운 작업에 맞춰 데이터 수집과 재학습이 필요했다.
• GAN Inversion: 복잡한 역추적 과정과 작업별 손실 함수 설계가 필요하며, 때로는 입력을 충실히 표현하지 못하는 문제점이 있었다.

SDEdit는 이 두 방식의 문제를 해결하며, 별도의 재학습 없이 범용적인 이미지 편집 및 생성을 지원한다.

3. SDEdit의 핵심 개념

SDE(Stochastic Differential Equation)의 이해

• SDE는 일반적인 미분 방정식에 무작위 노이즈를 더한 것이다. 이미지 생성에서 이 SDE는 원본 이미지를 잡음으로 서서히 변환한 뒤, 이 과정을 역으로 수행하여 잡음에서 사실적인 이미지를 얻는 방식이다.

VE-SDE(Variance Exploding SDE)와 VP-SDE(Variance Preserving SDE)

• VE-SDE: 시간이 지남에 따라 노이즈가 점점 커져 마지막에는 이미지가 순수한 잡음에 가까워진다.
• VP-SDE: 데이터의 분산을 유지하면서 점점 잡음으로 변환한다.

SDEdit는 특히 VE-SDE를 기반으로 설명된다.

4. SDEdit의 알고리즘

사용자로부터 가이드 이미지(간단한 스트로크 등)를 입력받아 다음의 과정을 수행한다:

1. 가이드 이미지에 적절한 수준의 가우시안 노이즈를 추가한다.
2. 이 노이즈가 추가된 이미지로부터 역방향 SDE를 반복적으로 적용하여 노이즈를 점점 제거한다.
3. 최종적으로 사실적이며 입력에 충실한 이미지를 얻는다.

이 과정에서 중요한 하이퍼파라미터는 t₀(노이즈 추가 정도)이며, 이 값이 클수록 사실성은 증가하지만 입력 충실도는 감소하는 trade-off가 있다.

5. 수식으로 이해하는 SDEdit

SDEdit의 핵심은 확률적 미분 방정식(SDE)을 활용해 이미지를 점점 사실적인 방향으로 복원하는 것이다. 이 과정은 수식적으로 다음과 같이 표현된다:

1) Forward SDE (노이즈 추가 과정)

SDE 모델은 원본 이미지 $\mathbf{x}(0)$에 시간에 따라 점점 강해지는 가우시안 노이즈를 더해 $\mathbf{x}(t)$를 만든다:

$\mathbf{x}(t) = \alpha(t)\mathbf{x}(0) + \sigma(t)\mathbf{z}, \quad \mathbf{z} \sim \mathcal{N}(0, \mathbf{I})$

• $\alpha(t)$: 원본 이미지 정보의 가중치
• $\sigma(t)$: 노이즈의 세기를 조절하는 함수

2) Reverse SDE (노이즈 제거 과정)

이제 $\mathbf{x}(t)$에서 다시 원본 이미지로 되돌아가는 과정은 다음과 같은 역방향 확률 미분 방정식으로 표현된다:

$d\mathbf{x}(t) = \left[ -\frac{d[\sigma^2(t)]}{dt} \nabla_{\mathbf{x}} \log p_t(\mathbf{x}) \right] dt + \sqrt{\frac{d[\sigma^2(t)]}{dt}} d\bar{w}$

$d\mathbf{x}(t) = -\underbrace{\frac{d\sigma^2(t)}{dt}}{\text{줄어드는 속도}} \cdot \underbrace{\nabla_x \log p_t(x)}{\text{복원 방향}} \cdot dt + \underbrace{ \sqrt{ \frac{d\sigma^2(t)}{dt} } }_{\text{무작위성 크기}} \cdot d\bar{w}$

확률 미분이란?

딥러닝에선 현실세계의 랜덤성을 부여하기 위해 확률 미분을 사용한다. $ dx(t) = a(t, x)dt + b(t, x)dW_t $

• $dx(t)$: 시간 $t$에서의 아주 작은 변화량. 여기에 무작위성이 포함.
• $a(t, x)dt$: 일반적인 변화 (기울기)
• $b(t, x)dW_t$: 랜덤성 추가

3) 학습: Score Matching Loss

모델은 score function을 다음과 같은 손실 함수를 통해 학습한다:

$ L_t = \mathbb{E}{\mathbf{x}(0) \sim p{\text{data}}, \ \mathbf{z} \sim \mathcal{N}(0, \mathbf{I})} \left[ \left| \sigma_t s_\theta(\mathbf{x}(t), t) - \mathbf{z} \right|^2 \right]$

4) 샘플링: Euler-Maruyama로 구현

실제 샘플링은 역방향 SDE를 유한 시간 간격으로 근사하여 아래와 같이 구현된다:

$ \mathbf{x}(t) = \mathbf{x}(t + \Delta t) + (\sigma^2(t) - \sigma^2(t + \Delta t)) s_\theta(\mathbf{x}(t), t) + \sqrt{\sigma^2(t) - \sigma^2(t + \Delta t)} \mathbf{z} $

이를 반복함으로써 점차 현실적인 이미지를 얻는다.

6. 실험 및 결과

SDEdit는 다음과 같은 다양한 이미지 작업에서 탁월한 성능을 보였다:

• 스트로크 기반 이미지 생성
• 이미지 합성(Image compositing)
• 스트로크 기반 이미지 편집

특히, 인간의 평가에서 기존 GAN 기반 방법들보다 현실성에서는 최대 98.09%, 전체 만족도(현실성+입력 충실도)에서는 최대 91.72% 더 높은 평가를 받았다.

7. SDEdit의 장점 요약

• 범용성: 별도의 데이터 수집이나 모델 재학습 없이 다양한 이미지 작업을 지원한다.
• 사실성과 충실도의 균형: 사용자의 의도를 정확히 반영하면서도 매우 현실적인 이미지를 생성할 수 있다.
• 간단한 적용: 기존에 미리 학습된 SDE 기반 모델을 바로 활용할 수 있다.

8. 의의

• 확산 모델의 표현력 활용: SDEdit는 확산 모델이 가진 고해상도 이미지 생성 능력을 편집 작업에도 효과적으로 활용.
• GAN의 한계 극복: 기존 GAN 기반 방식이 가진 재학습, 최적화 불안정성, latent space 제약 등의 한계를 해결..
• 재학습 없이 다양한 편집 가능: 한 번 학습된 확산 모델만으로 스트로크 기반 생성, 편집, 이미지 합성까지 수행할 수 있어 실용성이 높다.
• 조건부 생성의 새로운 방향 제시: 확산 모델에서 사용자 가이드를 중간 노이즈 수준(t₀)에서 삽입하는 방식은 이후 다양한 diffusion 기반 편집 모델에 영향을 주었다.

참고

• Chenlin Meng et al., "SDEdit: Guided Image Synthesis and Editing with Stochastic Differential Equations", Stanford University, 2022.

등장 배경

기존의 Diffusion Model은 픽셀 단위에서 동작해서 고해상도 이미지 생성 시 연산량과 시간이 매우 많이 필요했다.

개요

LDM = Autoencoder + Diffusion Model

의의

1. 계산 효율성 극대화 기존 픽셀 단위 Diffusion Model은 매우 높은 계산 비용을 요구했는데, LDM은 오토인코더를 통해 잠재공간에서 계산을 수행하므로 연산 비용과 메모리 사용량을 크게 줄일 수 있다. 개인 소규모 연구실에서도 고성능 이미지 생성 모델을 사용할 수 있게 되어, Diffusion Model의 활용 가능성을 확대했다.
2. 고해상도 이미지 생성 가능 기존 모델의 픽셀 기반 접근은 고해상도 이미지에서 매우 많은 연산량이 필요했지만, LDM은 잠재공간을 통해 높은 해상도의 이미지(예: 512×512, 1024×1024 픽셀 등)를 상대적으로 적은 연산량으로 생성 가능하게 만들었다.

구조

LDM은 AutoEncoder 구조를 활용해 다음과 같이 동작한다.

1. 이미지 → [인코더] → 잠재표현

   • 이미지 데이터를 인코더를 통해 낮은 차원의 잠재공간(latent space)으로 압축한다.

2. 잠재표현 → [Latent Diffusion 모델] → 새로운 잠재표현 생성

   • Diffusion 모델은 이 압축된 잠재공간에서 데이터의 확률적 구조를 학습하고, 새로운 잠재표현을 생성한다.

3. 생성된 잠재표현 → [디코더] → 최종 이미지 생성

   • 디코더는 생성된 잠재표현을 고해상도 이미지로 복원한다.

즉, LDM은 AutoEncoder 구조를 통해 복잡한 고차원 이미지 공간을 더 간결하고 연산 효율적인 잠재 공간으로 변환한 뒤, 이 공간에서 이미지 생성을 수행한다.

loss function

DM에서는 오토인코더를 훈련할 때, 두 가지 손실을 같이 사용한다:

• Perceptual Loss: 사람이 보기 좋다고 느끼는 기준에 가까운지 평가.
• Patch-based GAN Loss: 생성된 이미지가 작은 조각 하나하나에서도 진짜처럼 보이도록 유도.

논문 리딩

• 압축(Encoding) → 복원(Decoding) 과정
• 이미지를 압축해서 중요한 특징만 남김.
• 중복된 정보나 노이즈는 자연스럽게 제거되어 연산이 가벼움.
• 비지도 학습
  • 출력과 입력을 비교하기 때문에 정답 라벨 필요x.

구조

입력 X ─▶ [Encoder] ─▶ 잠재 표현 Z ─▶ [Decoder] ─▶ 복원된 X'

Latent Space (잠재 공간): 핵심 특징만 담은 벡터 (차원이 작음)

입력 X
  ↓
[Encoder]
  - Linear(784 → 256)
  - ReLU
  - Linear(256 → 64)
  ↓
Latent Vector (64차원)
  ↓
[Decoder]
  - Linear(64 → 256)
  - ReLU
  - Linear(256 → 784)
  - Sigmoid
  ↓
출력 X' (복원된 입력)

Loss function

복원된 X'와 원래 입력 X의 차이를 줄이는 게 목표. 대표적인 손실 함수: MSE (Mean Squared Error)

python 예제

"""
[입력 이미지: 28x28]
→ 인코더: Conv + ReLU + MaxPool
→ 잠재 표현: 압축된 Feature Map
→ 디코더: ConvTranspose + ReLU
→ 출력 이미지: 28x28 복원
"""
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt

# 장치 설정 (GPU 사용 가능 시 GPU 사용)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 하이퍼파라미터
epochs = 5
batch_size = 128
learning_rate = 1e-3

# MNIST 데이터셋 불러오기 (흑백 이미지 28x28)
transform = transforms.ToTensor()
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

# CNN Autoencoder 클래스 정의
class CNNAutoencoder(nn.Module):
    def __init__(self):
        super(CNNAutoencoder, self).__init__()

        # 인코더: Conv → ReLU → MaxPool
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=3, padding=1),   # 28x28 → 16x28x28
            nn.ReLU(),
            nn.MaxPool2d(2, 2),                           # → 16x14x14

            nn.Conv2d(16, 8, kernel_size=3, padding=1),   # → 8x14x14
            nn.ReLU(),
            nn.MaxPool2d(2, 2)                            # → 8x7x7
        )

        # 디코더: ConvTranspose → ReLU → 복원
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(8, 16, kernel_size=2, stride=2),  # → 16x14x14
            nn.ReLU(),

            nn.ConvTranspose2d(16, 1, kernel_size=2, stride=2),  # → 1x28x28
            nn.Sigmoid()  # 픽셀 값 0~1로 맞춤
        )

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

# 모델, 손실 함수, 옵티마이저 정의
model = CNNAutoencoder().to(device)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 학습 루프
for epoch in range(epochs):
    for data, _ in train_loader:
        data = data.to(device)

        # 순전파
        output = model(data)
        loss = criterion(output, data)

        # 역전파
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')

# 테스트용 이미지 시각화
with torch.no_grad():
    sample = next(iter(train_loader))[0][:6].to(device)  # 6장 샘플 이미지
    reconstructed = model(sample).cpu()

# 결과 시각화
plt.figure(figsize=(9,2))
for i in range(6):
    # 원본
    plt.subplot(2,6,i+1)
    plt.imshow(sample[i].cpu().squeeze(), cmap='gray')
    plt.title("Original")
    plt.axis('off')

    # 복원
    plt.subplot(2,6,i+7)
    plt.imshow(reconstructed[i].squeeze(), cmap='gray')
    plt.title("Reconstructed")
    plt.axis('off')

plt.tight_layout()
plt.show()

VAE(Variational Autoencoder)

• 확률 기반의 생성 모델
• Autoencoder 구조를 따르면서도 잠재공간(latent space)을 확률 분포로 모델링

Loss function

$ \text{Loss} = \text{Reconstruction Loss} + \text{KL Divergence} $

1. Reconstruction Loss (복원 손실)

• 일반 Autoencoder와 동일: 입력 x와 출력 x'의 차이를 줄임
• 예: MSE, BCE 등

2. KL Divergence (Kullback-Leibler Divergence)

• z의 분포 q(z|x)가 표준 정규분포 N(0,1)에 가까워지도록 강제함
• 즉, 잠재 공간을 더 부드럽고 연속적인 구조로 만들기 위한 정규화

ddpm 논문을 읽기 전 필요한 배경 지식으로 diffusion model이 있다.

Ddpm의 의의는

• Diffusion Model을 딥러닝 기반 이미지 생성 모델로 발전시킴.
• Neural Network를 활용한 Reverse Process 학습을 제안하여 실용화. 에 있다 ddpm 논문에서는 diffusion model을 diffusion Probabilistic Model이라고 지칭한다. '확률적' 관점을 더 강조한 느낌.

이미지에 점진적으로 노이즈를 추가하고, 노이즈를 다시 없애면서 원본 이미지를 복원 목표:

• 고품질 이미지 생성
• 이미지 복원 등

모델 개요

Forward Process

1. $q(x_{1:T} | x_0) := \prod_{t=1}^{T} q(x_t | x_{t-1})$
   • 노이즈를 점진적으로 추가하는 과정
   • 전체 마르코프 과정의 결합 확률 분포
   • 각 시간 단계에서 노이즈를 추가하는 과정은 바로 직전 단계에만 의존한다.
   • 각 시간 단계에서 상태가 $x_t$ →$x_{t+1}$로 변할 확률을 모두 고려한 결합 확률 분포

마르코프 과정:

현재 상태가 오로지 직전 상태에만 의존하는 확률 과정. 즉, 현재 $x_t$는 바로 이전 상태 $x_{t-1}$만 참조하고 그 이전의 데이터와는 직접적인 관련이 없음.

그런데 왜 모든 시점의 확률을 곱할까?

수식은 마르코프 과정 전체에 대한 결합 확률 분포를 표현하기 때문임.각 단계의 확률을 개별적으로 정의x, 과정 전체에서 발생할 확률을 계산하려는 거다. 요소 설명 - $q(x_{1:T} | x_0)$: 정방향 과정에서 원본 데이터 $x_0$가 주어졌을 때, $x_1$, $x_2$, ..., $x_T$까지 점진적으로 노이즈를 추가하는 전체 과정의 확률 - $\prod_{t=1}^{T} q(x_t | x_{t-1})$: 각 단계에서 $x_{t-1}$에서$x_t$로 변할 확률을 전부 곱한 것

2. $q(x_t | x_{t-1}) = \mathcal{N}(x_t; \sqrt{1 - \beta_t} x_{t-1}, \beta_t I)$

• t-1 단계에서 t 단계로 넘어갈 때 노이즈를 점진적으로 추가. 각 수식은 픽셀 하나의 값에 대해 적용된다. 즉, $x_t$와 $x_{t-1}$의 각 픽셀 값은 서로 같은 위치에서 매칭되고, 같은 위치의 $x_{t-1}$ 픽셀 값에 직접적인 영향(Markov Chain의 원리)을 받아 $x_t$의 값이 결정된다.

수식 설명

• $q(x_t | x_{t-1})$: 이전 단계 $x_{t-1}$가 주어졌을 때, $x_t$가 어떻게 분포하는지를 나타내는 조건부 확률 분포

• $N(x_t ; \sqrt{1 - \beta_t} x_{t-1}, \beta_t I)$: $x_t$는 평균이 $\sqrt{1 - \beta_t} x_{t-1}$, 분산이 $\beta_t I$인 가우시안 분포에서 샘플링된 데이터 = $x_t$의 모든 픽셀 값이 각 $x_{t-1}$를 중심으로 하는 가우시안 분포에서 샘플링된 값

  • $x_t$: $t$ 시점의 노이즈가 추가된 데이터
  • $x_{t-1}$: $t-1$ 시점의 노이즈가 추가된 데이터
  • $\beta_t$: 각 시점에서 노이즈 크기를 조절하는 파라미터 (Variance Schedule)
  • $\mathcal{N}(\mu, \sigma^2)$: 평균이 $\mu$, 분산이 $\sigma^2$인 가우시안 분포(정규분포)
  • $I$: 단위 행렬 (각 데이터 차원에서 독립적으로 노이즈가 추가됨을 의미)

Reverse Process

노이즈를 제거하면서 이미지를 복원 학습 목표: 역방향 확률 분포 모델링 (모델이 학습하는 부분)

수식

1. $p_\theta(x_{0:T}) := p(x_T) \prod_{t=1}^T p_\theta(x_{t-1} | x_t)$

• 전체 마르코프 과정의 결합 확률 분포

• $x_T$에서 시작해 $x_0$으로 도달할 때의 확률을 계산하는 과정

• 이 노이즈에서 시작했을 때, 특정한 과정을 거쳐 원래 데이터로 복원될 확률은 얼마일까?

  요소 설명

  • $p(x_T)$: 초기 상태의 노이즈 확률 분포. 초기는 완전 노이즈이기 때문에 아마 가우시안 분포를 따른다고 가정.
  • $\prod_{t=1}^T p_\theta(x_{t-1} | x_t)$: 각 단계에서 $x_T$에서 $x_{T-1}$로 변할 확률을 모두 곱한 것. 즉, 모든 시간 단계에서의 조건부 확률을 곱해서 전체 확률을 계산함.

2. $p_\theta(x_{t-1} | x_t) = \mathcal{N}(x_{t-1}; \mu_\theta(x_t, t), \Sigma_\theta(x_t, t))$

• $p_\theta(x_{t-1} | x_t)$: 현재 단계 $x_t$가 주어졌을 때, 이전 단계 $x_{t-1}$가 어떻게 분포하는지를 나타내는 조건부 확률 분포
• $\mathcal{N}(x_{t-1}; \mu_\theta(x_t, t), \Sigma_\theta(x_t, t))$: 정규 분포로, $x_{t-1}$는 평균이 $\mu_\theta(x_t, t)$, 분산이 $\Sigma_\theta(x_t, t)$인 가우시안 분포에서 샘플링된 값

수식 내 요소 설명

• $\theta$: 학습 가능한 파라미터. $\theta$가 붙은 기호는 예측하는 값 또는 학습되는 값이라고 생각하면 됨.
• $\mu_\theta(x_t, t)$:
  • $x$와 $t$를 입력으로 받아 평균값 $\mu$를 반환하는 함수.
    • $x_t$: 데이터(변화하는 입력) 즉, t 시점에서의 x값
    • $t$: 시간 또는 상태를 조절하는 파라미터
  • 평균값으로, 모델이 예측하는 값. 고정된 수식이 아니라, 학습 가능한 값!! 특정 규칙으로 고정된 평균값이 아니라, 학습 과정에서 동적으로 결정되는 값!
  • $x_t$가 주어졌을 때 가장 가능성이 높은 $x_{t-1}$의 값
• $\Sigma_\theta(x_t, t)$: $x_t$ 시점에서 $x_{t-1}$로 이동할 때, $x_{t-1}$의 분산을 예측한 값
  • $\Sigma_\theta$: 가우시안 분포의 공분산 행렬

    분산 vs 공분산 행렬

  • 분산*: 하나의 변수의 변동성
  • 공분산 행렬*: 다차원 데이터의 각 변수 간의 상관관계와 변동성을 동시에 나타냄. 너가 adp 공부할 때 배웠던 그 공분산 맞아~

💡 표기법의 일반적 관습

1. $p()$
   • 학습해야 할 확률 분포 또는 실제 데이터 분포를 나타냄.
   • ex: $p(x)$: 데이터 $x$의 진짜 분포를 의미.
2. $q()$
   • 근사 분포를 나타낼 때 사용.
   • ex: $q(x | y)$: $y$ 조건 하에서 $x$를 근사하는 분포를 나타낸다.
   • Forward process에서 $q(x_t | x_{t-1})$는 고정된 근사 분포이기 때문에 $q$를 사용.

각 단계가 연결된 사건이므로 전체 확률을 구하려면 모든 단계의 확률을 곱해줘야함.

예를 들어, 특정한 경로를 따른다고 가정하면:

• 노이즈 $x_T$에서 $x_{T-1}$로 변할 확률: $P(x_{T-1} | x_T)$
• $x_{T-1}$에서 $x_{T-2}$로 변할 확률: $P(x_{T-2} | x_{T-1})$ …
• 마지막으로$x_1$에서 ( x_0 )로 변할 확률: $P(x_0 | x_1)$

그러면, 전체 확률은?? $P(x_0, x_1, ..., x_T) = P(x_T) \times P(x_{T-1} | x_T) \times P(x_{T-2} | x_{T-1}) \times \cdots \times P(x_0 | x_1)$

DDPM의 손실 함수

수식 (3)

$E[−\log p_{\theta}(x_0)] \leq E_q [-\log q(x_{1:T} | x_0)] = E_q [-\log p(x_T) - \sum_{t\geq1} \log \frac{p_{\theta}(x_{t-1} | x_t)}{q(x_t | x_{t-1})}] =: L$

1. 목표: $p_{\theta}(x_0)$을 최대화하는 것. $p_{\theta}(x_0)$: 노이즈에서 원본을 되찾을 확률. 근데 보통 딥러닝에서 최대화하는 것보단 최소화로 변환해서 사용한다. 왜냐면 계산하기 더 쉽기 때문에. -> Negative Log-Likelihood (NLL, 음의 로그 가능도) 를 사용 직접 최적화하기 어려우므로 -> 변분 추정을 이용하여 우상향 경계를 설정한다.

$max(p_{\theta}(x_0)) -> min(logp_{\theta}(x_0))$

log를 왜 이용할까?

변분추정(variational bound): 확률을 계산할 때, 그 수식이 너무 복잡하므로 그 값을 근사하게 계산함.

손실함수 유도 차근히 뜯어보기

변분추론을 적용한 전개 우리는 $p_\theta(x_0)$를 직접 계산하기 어려우니까, 대신 전체 마르코프 체인 확률을 사용해서 근사할 수 있어.

$ p_\theta(x_0) = \int p_\theta(x_{0:T}) dx_{1:T} $

이걸 로그를 취하면:

$ \log p_\theta(x_0) = \log \int p_\theta(x_{0:T}) dx_{1:T} $

이 식을 다루기 어렵기 때문에 Jensen's Inequality (옌센 부등식) 을 사용하면:

$ \log p_\theta(x_0) \geq \mathbb{E}q \left[ \log \frac{p_\theta(x{0:T})}{q(x_{1:T} | x_0)} \right] $

옌센(젠센) 부등식(Jensen's Inequality)란? "평균을 먼저 구하고 함수 적용" 한 값은, "먼저 함수 적용한 후 평균" 을 낸 값보다 항상 작거나 같다!를 이용한 등식 $ f(\mathbb{E}[X]) \leq \mathbb{E}[f(X)] $

이제 좌변에 음수를 곱해서 최소화 문제로 바꾸면:

$ -\log p_\theta(x_0) \leq \mathbb{E}q \left[ - \log \frac{p_\theta(x{0:T})}{q(x_{1:T} | x_0)} \right] $

기대값을 추가하면:

$ \mathbb{E}[- \log p_\theta(x_0)] \leq \mathbb{E}q \left[ - \log \frac{p_\theta(x{0:T})}{q(x_{1:T} | x_0)} \right] $ 짠. 논문의 (3)번 식이 된다.

다시 지피티한테 물어봄. 식 유도에 대해. 비전공자로서 이해가 된 답변을 가져옴.

우리가 원래 하고 싶은 건 $p_\theta(x_0)$를 직접 최적화하는 것이야.
즉, 우리가 원하는 최적화 목표는:

$ \max p_\theta(x_0)$

하지만 딥러닝에서 직접 확률을 다루는 대신 Negative Log-Likelihood (NLL) 를 최소화하는 방식으로 바꿔서 최적화하는 게 일반적이야:

$ \min -\log p_\theta(x_0) $

즉, 확률을 최대화하는 대신, 음의 로그 가능도를 최소화하는 문제로 바꾼 것!
이렇게 하면 수학적으로 계산하기 편하고, 경사 하강법(Gradient Descent)으로 최적화하기 쉬워. -> 여기까진 이해 o

그런데 왜 기대값이 등장하는가? ✅ 문제: $p_\theta(x_0)$ 를 직접 계산하기 어렵다! $p_\theta(x_0)$를 계산하려면 전체 마르코프 체인에서 $x_0$가 나올 확률을 다 합쳐야 해.
즉, $x_T$부터 시작해서 $x_0$까지 오는 모든 가능성을 고려해야 해.

이걸 수식으로 쓰면: $ p_\theta(x_0) = \int p_\theta(x_{0:T}) dx_{1:T} $

즉, $x_{1:T}$에 대해 적분(총합)을 취해야 하는데, 이 적분을 직접 계산하는 건 너무 복잡해!
그래서 적분을 기대값 형태로 변형해서 다루기 쉽게 바꾸는 거야.

기억나니? 그래프의 아래 면적을 적분으로 구하는 거? 적분이 기대값과 완전 같은 개념은 아니지만 기대값을 확률 분포에서 구하려면 적분이 필요함.

적분을 기대값(평균) 형태로 변형하는 과정 우리는 적분을 아래처럼 변형할 수 있어:

$ p_\theta(x_0) = \int p_\theta(x_{0:T}) dx_{1:T} $

이제 $q(x_{1:T} | x_0)$ (forward process) 를 곱하고 나누면?

$ p_\theta(x_0) = \int \frac{p_\theta(x_{0:T})}{q(x_{1:T} | x_0)} q(x_{1:T} | x_0) dx_{1:T} $

이제 기대값(Expectation) 형태로 바꾸면:

$ p_\theta(x_0) = \mathbb{E}{q(x{1:T} | x_0)} \left[ \frac{p_\theta(x_{0:T})}{q(x_{1:T} | x_0)} \right] $

즉,
"적분을 직접 계산하는 대신, $q(x_{1:T} | x_0)$ 에 대해 평균을 취한 값으로 표현할 수 있다!"
이게 바로 기대값이 등장한 이유야.

그런데 왜 옌센 부등식이 등장하는가? 우리는 이제 최적화 문제를 다음과 같이 바꿀 있다.

$ \min -\log p_\theta(x_0) $

이제 여기서 옌센 부등식을 적용하려고 하는데, 왜 그럴까?
왜냐하면, 우리가 위에서 유도한 기대값(평균) 은 로그 바깥에 있기 때문이야:

$ \log p_\theta(x_0) = \log \mathbb{E}{q(x{1:T} | x_0)} \left[ \frac{p_\theta(x_{0:T})}{q(x_{1:T} | x_0)} \right] $

여기서 핵심적인 문제:

✅ 로그 안에 기대값이 들어 있으면 직접 최적화하기 어렵다!
✅ 기대값(평균)을 로그 바깥으로 빼야 한다!

옌센 부등식은 바로 이 로그를 바깥으로 빼주는 역할을 해.
즉, 옌센 부등식의 성질을 이용하면, 기대값을 로그 바깥으로 뺄 수 있다!

$ \log \mathbb{E}[X] \geq \mathbb{E}[\log X] $

이걸 적용하면:

$ \log p_\theta(x_0) = \log \mathbb{E}{q(x{1:T} | x_0)} \left[ \frac{p_\theta(x_{0:T})}{q(x_{1:T} | x_0)} \right] \geq \mathbb{E}{q(x{1:T} | x_0)} \left[ \log \frac{p_\theta(x_{0:T})}{q(x_{1:T} | x_0)} \right] $

즉, 우리는 로그 안의 기대값을 직접 최적화할 수 없으니까, 대신 우변을 최적화하는 방식으로 변환한 거야!

수식 (4)

Forward 과정에서 특정한 시점 t의 이미지를 바로 샘플링하는 수식

수식 (5) - Variational Bound (변분 경계)를 이용하여 손실함수

손실 함수(loss function)* 를 정의

논문의 수식 (5) 에 대해서 차근차근 자세히 설명해줄게!

이 수식은 DDPM에서 손실 함수(loss function) 를 정의하는 중요한 식이야.
즉, 모델이 어떻게 학습되는지를 결정하는 핵심적인 역할을 해.

수식 (5)의 기본 개념: Variational Bound (변분 경계)

DDPM 모델은 원래 확률 모델이다. 목표: $ ( p_\theta(x_0) )$ 즉, 모델이 생성한 데이터 분포가 실제 데이터 분포 ( q(x_0) ) 와 최대한 비슷해지는 것.

음의 로그 우도(Negative Log Likelihood, NLL) 를 최소화하여 최적화 시킬 수 있음.

$ -\log p_\theta(x_0) $

하지만 직접적으로 계산하기 어렵기 때문에, 변분 경계(VB, Variational Bound) 라는 테크닉을 사용해서 대신 최적화할 수 있다.

<수식 (5)의 항 분석> $ L = \mathbb{E}q \Big[ D{KL}(q(x_T | x_0) || p(x_T)) + \sum_{t=1}^{T} D_{KL}(q(x_{t-1} | x_t, x_0) || p_\theta(x_{t-1} | x_t)) \Big] $

(1) 첫 번째 KL 발산 항: $ D_{KL}(q(x_T | x_0) || p(x_T)) $

: Forward 과정의 마지막 단계에서 $x_T$ 가 노이즈 분포 $p(x_T)$ 와 얼마나 다른지를 측정하는 항

즉,

• Forward 과정에서 마지막 ( x_T ) 는 우리가 설계한 ( q(x_T | x_0) ) 로부터 나오는데,
• 우리가 모델에서 가정한 초기 노이즈 분포 $p(x_T)$는 보통 정규분포 $\mathcal{N}(0, I)$ 를 따르게 설정한다.
• 그러므로 이 KL 발산 항을 최소화하면, Forward 과정이 $x_T$에서 우리가 원하는 가우시안 분포로 잘 수렴하도록 도와줌.

-> 학습 과정에서 상수값이 되기 때문에 무시.

(2) 두 번째 KL 발산 항: $D_{KL}(q(x_{t-1} | x_t, x_0) || p_\theta(x_{t-1} | x_t))$

"모델 $p_\theta(x_{t-1} | x_t)$이 실제 역과정(Reverse process) 분포 $q(x_{t-1} | x_t, x_0)$를 얼마나 잘 따라가는지" 를 측정.

• $q(x_{t-1} | x_t, x_0)$: Forward 과정에서 우리가 정의한 실제 노이즈 제거 확률 분포 (Ground truth)
• $p_\theta(x_{t-1} | x_t)$: 우리가 학습하려는 역과정(Reverse process)의 모델 예측 값
• KL 발산 $D_{KL}$: 두 확률 분포의 차이를 나타냄

이 KL 발산 값을 최소화하면?
-> 모델 $p_\theta(x_{t-1} | x_t)$ 가 실제 Forward 과정에서의 노이즈 제거 분포 $q(x_{t-1} | x_t, x_0)$와 최대한 비슷해지도록 학습됨을 의미.

최적화 방식 (손실 함수 L을 어떻게 학습하나?) 최적화해야 하는 손실 함수 $L$ 은 결국:

$ L = \sum_{t=1}^{T} D_{KL}(q(x_{t-1} | x_t, x_0) || p_\theta(x_{t-1} | x_t)) $ 이다.

즉, Forward 과정에서 정의한 $q(x_{t-1} | x_t, x_0)$ 를 모델이 예측하는 $p_\theta(x_{t-1} | x_t)$ 가 최대한 비슷하게 만들도록 학습하는 것.

논문에서는 이 KL 발산을 직접 최소화하기보다는,
Forward 과정에서 한 번에 샘플링할 수 있는 ( x_t = \sqrt{\bar{\alpha}_t} x_0 + \sqrt{1 - \bar{\alpha}_t} \epsilon )
이 수식을 활용해서 모델이 노이즈 $\epsilon$을 예측하는 방식으로 학습한다.

즉, 최종적으로 손실 함수는 모델이 예측한 노이즈와 실제 노이즈 간의 차이를 최소화하는 방식으로 변형한다.

KL 발산(KL Divergence, Kullback-Leibler Divergence)이란?

• 두 확률 분포가 얼마나 다른지를 측정하는 방법
  • 즉, 우리가 만든 모델의 분포가 실제 데이터의 분포와 얼마나 비슷한지를 평가.
• 수식: $ D_{KL}(P || Q) = \sum_x P(x) \log \frac{P(x)}{Q(x)} $
  • $P(x)$: 실제 따르고 싶은 "참된" 확률 분포 (Ground truth)
  • $Q(x)$: 모델을 통해 학습하고 싶은 확률 분포 (모델의 예측)
  • KL 발산 $D_{KL}(P || Q)$: 두 확률 분포가 얼마나 다른지 수치적으로 나타내는 값.
    즉, KL 발산은 "Q(x) 가 P(x) 와 얼마나 비슷한지를 측정하는 척도"

• 직관적 이해* 만약 $P(x)$와 $Q(x)$ 가 완전히 동일하면?
  • $\frac{P(x)}{Q(x)} = 1$이 되고,
  • $\log 1 = 0$이므로 KL 발산 = 0
  • 즉, 두 분포가 같으면 KL 발산 값은 0이다.
    만약 $Q(x)$가 $P(x)$와 다르다면?
  • $\frac{P(x)}{Q(x)}$값이 커지거나 작아지면서 KL 발산 값이 증가함.
  • 즉, KL 발산 값이 클수록 두 분포가 다르다는 의미야.

• DDPM에서 KL 발산은 어디에 쓰일까?* DDPM 논문에서는 KL 발산을 이용해서 Forward 과정과 Reverse 과정의 차이를 줄이는 것이 목적.

• 수식 (5)* 에 나왔던 KL 발산: $ D_{KL}(q(x_{t-1} | x_t, x_0) || p_\theta(x_{t-1} | x_t)) $ 이 KL 발산을 최소화하면: 👉 모델이 $x_t$를 보고 $x_{t-1}$ 를 예측하는 방법이 실제 데이터 분포를 따르도록 학습된다는 의미.
  DDPM에서는 KL 발산을 사용해서:

1. Forward 과정에서 설계한 노이즈 추가 과정
2. Reverse 과정에서 모델이 학습한 노이즈 제거 과정이 최대한 비슷하도록 만듦.

수식 (6), (7)

Forward 과정에서 정의된 분포 $q(x_{t-1} | x_t, x_0)$를 구하는 과정에서 유도된 식. Reverse 과정에서 원래 데이터로 복원하는 확률 분포를 정확하게 구하는 방법을 설명하는 핵심적인 식이다.

1️⃣ 수식 (6): $ q(x_{t-1} | x_t, x_0) = \mathcal{N}(x_{t-1}; \tilde{\mu}t(x_t, x_0), \tilde{\beta}_t I) $ **Forward 과정에서 $x_t$가 주어졌을 때, 한 단계 전인$x{t-1}$의 분포를 구하는 공식**

• 평균(Mean): $\tilde{\mu}_t(x_t, x_0)$
  • $x_t$와 $x_0$의 가중합(weighted sum)으로 표현됨.
• 분산(Variance): $\tilde{\beta}_t$
  • Forward 과정에서 정의된 $\beta_t$값을 조정한 형태.

2️⃣ 수식 (7):

평균$\tilde{\mu}_t(x_t, x_0)$: $ \tilde{\mu}t(x_t, x_0) := \frac{\sqrt{\bar{\alpha}{t-1}} \beta_t}{1 - \bar{\alpha}t} x_0 + \frac{\sqrt{\alpha_t} (1 - \bar{\alpha}{t-1})}{1 - \bar{\alpha}_t} x_t $

1. $x_t$와 $x_0$를 적절히 조합해서$x_{t-1}$의 평균을 구할 수 있다.
   • $x_0$에 가중치 $\frac{\sqrt{\bar{\alpha}_{t-1}} \beta_t}{1 - \bar{\alpha}_t}$를 곱한 항
   • $x_t$에 가중치 $\frac{\sqrt{\alpha_t} (1 - \bar{\alpha}_{t-1})}{1 - \bar{\alpha}_t}$를 곱한 항
2. Forward 과정에서 $x_t$가 $x_0$와 노이즈 $\epsilon$의 조합으로 되어 있기 때문에, 역방향으로 추정할 때도 이 두 항이 사용됨.
3. 즉, 이 평균 값은 Forward 과정에서 $x_t$가 어떻게 만들어졌는지를 반대로 계산해서 ( x_{t-1} ) 를 구하는 과정이다.

분산 $\tilde{\beta}_t$: $ \tilde{\beta}t := \frac{1 - \bar{\alpha}{t-1}}{1 - \bar{\alpha}_t} \beta_t $

Forward 과정에서 정의된 노이즈 $\beta_t$를 조정해서 역과정에 적절하게 맞추는 역할

• 여기서 $\bar{\alpha}t = \prod{s=1}^{t} \alpha_s$ (누적된 노이즈 조절 계수)
• Forward 과정에서 $x_t$ 가 점점 흐려지면서, 노이즈가 추가된 정도를 반영한 값.

$x_t$ 를 보고 $x_{t-1}$를 샘플링할 때, 노이즈를 얼마나 추가할지 조절하는 값

3️⃣ 수식의 의의 **Reverse 과정에서 정확하게 $x_{t-1}$를 샘플링할 수 있도록 도와줌.

• Forward 과정에서 $x_t$ 를 $x_{t-1}$로부터 노이즈를 추가해서 만들었었다.
• 그런데 역과정에서는 노이즈가 추가된 $x_t$를 보고 원래 $x_{t-1}$를 복원해야 한다.
• 이때, $q(x_{t-1} | x_t, x_0)$를 알면 Forward 과정에서 $x_t$를 만들었던 방법을 거꾸로 되돌리는 확률 분포 를 정확하게 구할 수 있다.

3. Diffusion models and denoising autoencoders (디퓨전 모델과 잡음 auto encoders)

• 확산 모델은 제한적인 것처럼 보이지만 구현 자유도가 크다.
• Forward 과정의 βₜ, 역과정의 가우시안 분포 파라미터화, 모델 아키텍처를 결정해야 한다.
• 확산 모델과 Denoising Score Matching의 연결을 밝힘으로써, 손실 함수를 단순화할 수 있다.
• 모델 설계의 타당성은 단순함과 실험적 결과를 통해 증명된다.
• 논의는 수식 (5)의 항목들에 따라 진행될 것이다.

3.1 Forward process and $L_T$

• Forward 과정의 분산 $\beta_t$를 학습할 수도 있지만, 이 논문에서는 상수로 고정 -> Forward 과정의 근사 사후분포 $q$에 학습할 파라미터가 없게 된다.** ->$L_T$ (손실 함수의 일부 항)이 상수가 되므로, 학습 과정에서 무시됨**

3.2 Reverse process and $L_{1:T-1}$

• Reverse 과정의 분산 $\Sigma_\theta(x_t, t)$를 학습하지 않고 고정된 상수 $\sigma_t^2$로 설정.
• 실험적으로 $\sigma_t^2 = \beta_t$ 와 $\sigma_t^2 = \tilde{\beta}_t$ 를 사용했을 때 비슷한 결과가 나왔다.
• Reverse 과정의 평균 $\mu_\theta(x_t, t)$ 를 예측하는 가장 간단한 방법은 Forward 과정의 사후분포 평균 $\tilde{\mu}_t$ 를 직접 예측하는 것이다.
• 수식 (4)와 수식 (7)을 활용하여 $x_t$ 를 $x_0$ 와 노이즈 $\epsilon$ 의 함수로 재구성할 수 있다.

수식 (8) - 최종 손실 함수

논문에서 사용한 최종 손실 함수는 (8)이다. 하지만 수식 (3)으로 부터 (5)를 유도했고, (5)로부터 (8)을 유도했다.

• 수식 (3): 논문의 기본 목표를 정의하는 손실 함수지만, 너무 일반적이어서 바로 사용할 수 없음.
• 수식 (5): 는 Forward와 Reverse 과정 간 KL 발산을 최소화하는 방식으로 손실을 구체화한 것이지만, 여전히 KL 발산을 직접 계산해야 하는 문제가 있음.
• 수식 (8): KL 발산을 풀어서 L2 Loss 형태로 변형.

CNN 백본(VGG-16)과 dilated convolution을 활용하여 넓은 수용영역을 확보하고, 군중 밀집 지역의 밀도를 예측하는 방식.

2. MCNN (Multi-Column CNN)

서로 다른 커널 크기를 가진 3개의 병렬 CNN을 사용하여 다양한 스케일의 정보를 학습하는 모델.

3. SCAR (Scale-aware Crowd Counting)

다중 스케일 특징을 동적으로 조절하여 군중 밀도에 맞게 적절한 스케일을 강조하는 모델.

4. SANet (Scale Aggregation Network)

다중 스케일 합성곱을 사용하여 서로 다른 크기의 특징을 효과적으로 조합하는 모델.

5. Transformer 기반 모델 (CCTrans 등)

Self-Attention을 활용하여 이미지 내 여러 스케일에서 정보를 추출하고, 군중 계수를 예측하는 방식.

2️⃣ Multi-Scale Crowd Counting 관련 논문 & 코드 분석

✅ 최신 연구를 통해, 실제 PCB 검사 적용 가능성을 평가

(1) 필수 논문 📄

💡 Multi-Scale 군중 계수 연구 트렌드
📌 논문을 읽을 때, Multi-Scale Feature Extraction 방식에 집중해서 분석

🔹 논문 읽기 추천 순서
1️⃣ MCNN → 2️⃣ CSRNet → 3️⃣ SCAR/SANet → 4️⃣ CCTrans

(2) 코드 실습 🔧

✅ 논문만 읽으면 이해하기 어려우니, 직접 코드를 실행하면서 구조를 익히기

• MCNN PyTorch 코드: https://github.com/ZhihengCV/Multi-Column-CNN-Crowd-Counting
• CSRNet PyTorch 코드: https://github.com/leeyeehoo/CSRNet-pytorch
• SANet PyTorch 코드: https://github.com/VisDrone/SANet

💡 분석 포인트
1️⃣ Feature Extractor가 어떻게 Multi-Scale 정보를 처리하는지 확인
2️⃣ Dilated CNN / FPN / Transformer 기반인지 분석
3️⃣ PCB 검사 모델과 비교: 기존 모델과의 차이점 찾기

3️⃣ Multi-Scale Feature 적용 실습

✅ 실무 적용을 위해 PCB 데이터셋으로 Multi-Scale Feature를 실험해 보기

(1) PCB 데이터 준비 & 전처리

✔ 기존 PCB 이미지 데이터 → Crowd Counting 방식으로 변환 가능?
✔ PCB 부품을 작은 객체(사람)처럼 보고 밀도 맵 생성 가능 여부 확인
✔ Data Augmentation 실험: Affine Transform, Color Jitter, Noise, Blur 등

(2) Multi-Scale Feature Extraction 비교 실험

✅ PCB 검사 모델에서 어떤 방식이 가장 효과적인지 실험
| 실험 모델 | 핵심 개념 | |-----------|----------| | Baseline CNN (ResNet, VGG) | 기존 모델 (비교 대상) | | Dilated CNN (CSRNet 방식) | 큰 수용 영역 활용 | | Multi-Column CNN (MCNN) | 다른 커널 크기로 Multi-Scale 정보 추출 | | Feature Pyramid Networks (FPN) | 해상도별로 다른 Feature 학습 | | Transformer 기반 (CCTrans) | Attention 기반 다중 스케일 학습 |

📌 결과 분석

• 어떤 모델이 PCB 검사에서 정확도가 더 높은지 실험
• Multi-Scale Feature가 작은 부품과 큰 부품을 동시에 잘 인식하는지 확인
• 실무 적용 가능 여부 평가

1. Atrous convolution (= Dilated Convolution)

dilation이 적용된 합성곱 dilation이란 아래 사진과 같이 픽셀 사이에 빈 공간을 사이사이에 넣는 것을 말한다.

수용 영역(Receptive Field)가 확장되어 더 넓은 범위의 정보 학습이 가능.

2. SSP (Spatial Pyramid Pooling)

입력 크기에 상관없이 고정된 크기의 특징 벡터를 만들 수 있는 풀링 기법.

ssp 필요한 이유

일반적인 CNN 구조에서 FC Layer를 사용하려면 고정된 크기의 입력이 필요하다. 하지만 입력 이미지 크기가 다르면 FC Layer에 입력할 수 없기 때문에 일반적으로 CNN에서는 고정된 크기로 Resizing을 해야 한다. 하지만 Resizing을 하려면 이미지 비율이 깨지거나 중요한 정보 손실될 수 있음.

따라서 다양한 크기의 풀링 윈도우를 사용하여 다중 스케일 정보를 유지하면서 고정된 크기의 출력 벡터 생성함.

다양한 크기의 풀링을 수행하여, 다중 스케일 정보를 하나의 벡터로 병합한다. 1x1 풀링 → 전체적인 정보 (전역 정보) 2x2 풀링 → 중간 크기의 정보 4x4 풀링 → 더 작은 영역의 정보 8x8 풀링 → 매우 작은 국소적(local) 정보

3. ASSP (Atrous Spatial Pyramid Pooling)

다중 스케일 정보를 효과적으로 캡쳐하기 위해 설계된 합성곱 연산 기법.

SPP(Spatial Pyramid Pooling)의 atrous 버전.

ASSP는 Pooling 대신 Atrous Convolution을 사용 → 공간 해상도를 유지하면서도 다중 스케일 정보를 추출할 수 있다.

출처: https://blog.naver.com/h22hyeon/222247290992

1. 문제 상황 진단

서버에 SSH 또는 로컬로 접속

ssh 사용자명@서버_IP

2. 실행 중인 프로세스 확인

ps -ef | grep 사용자명

• ps -ef: 현재 실행 중인 모든 프로세스를 상세히 출력.
• | (파이프): ps -ef 명령의 출력을 grep 명령에 전달.
• grep 사용자명: 해당 사용자와 관련된 프로세스만 필터링하여 출력.

출력 예시:

사용자명   2954205       1  0 11:08 ?        00:00:00 /usr/libexec/gvfs-goa-volume-monitor
사용자명   2954219       1  0 11:08 ?        00:00:00 /usr/libexec/goa-daemon
사용자명   2954545  2954205  0 11:09 ?        00:00:00 /usr/bin/ibus-daemon --xim

3. 문제 프로세스 종료

문제가 있는 프로세스를 종료하려면 kill 명령을 사용한다. 강제 종료가 필요할 경우 -9 옵션을 추가.

sudo kill -9 [프로세스 ID]

예시

sudo kill -9 2954219

• kill: 지정된 프로세스 종료.
• -9: 강제로 종료(SIGNAL 9)를 보냄. 프로세스가 정상적으로 응답하지 않을 경우 사용.

일반적인 CNN은 다음과 같은 순서로 배열된 레이어들로 구성됩니다:

1. 입력 레이어: 원시 픽셀 데이터를 받아들이는 레이어.
2. 합성곱 레이어: 입력 데이터에 합성곱 연산을 적용하여 특징을 추출.
3. 활성화 함수: 비선형성을 도입하여 모델의 표현력을 높임 (예: ReLU).
4. 풀링 레이어: 공간적 차원(높이와 너비)을 줄여 계산량을 감소시키고 과적합을 방지.
5. 완전 연결 레이어: 추출된 특징을 기반으로 높은 수준의 추론 및 분류를 수행.
6. 출력 레이어: 최종 예측이나 분류 결과를 제공.

예시로 각 레이어별 데이터 형태 변화 설명:

예시: 32x32 픽셀의 그레이스케일 이미지

1. 입력 레이어:

   • 입력 형태: (높이, 너비, 채널 수)
   • 예시 형태: (32, 32, 1) (그레이스케일 이미지이므로 채널 수는 1)

2. 첫 번째 합성곱 레이어:

   • 연산: 학습 가능한 필터(커널)를 입력에 적용.
   • 파라미터:
     • 필터 수 (예: 16개)
     • 커널 크기 (예: 3x3)
     • 스트라이드 (예: 1)
     • 패딩 (예: 'same' 또는 'valid')
   • 출력 계산:
     • 패딩이 'same'인 경우 출력 차원은 입력과 동일.
     • 출력 형태: (32, 32, 16) (필터 수 만큼 채널 증가)

   형태 변화 설명:

   • 패딩을 사용하여 높이와 너비는 유지.
   • 채널 수는 필터 수 만큼 증가.

3. 활성화 함수(ReLU 등):

   • 연산: 각 요소에 비선형 함수를 적용.
   • 출력 형태: 입력과 동일.
   • 활성화 후 형태: (32, 32, 16)

4. 첫 번째 풀링 레이어:

   • 연산: 윈도우 내에서 최대값이나 평균값을 취해 다운샘플링.
   • 파라미터:
     • 풀 크기 (예: 2x2)
     • 스트라이드 (예: 2)
   • 출력 계산:
     • 새로운 높이 = (이전 높이 - 풀 높이) / 스트라이드 + 1
     • 스트라이드가 풀 크기와 같고 'valid' 패딩인 경우 단순화됨.
   • 출력 형태: (16, 16, 16)

   형태 변화 설명:

   • 풀링을 통해 높이와 너비가 절반으로 감소.
   • 채널 수는 그대로 유지.

5. 두 번째 합성곱 레이어:

   • 파라미터:
     • 필터 수 (예: 32개)
     • 커널 크기 (예: 3x3)
     • 스트라이드 (예: 1)
     • 패딩 (예: 'same')
   • 출력 형태: (16, 16, 32)

6. 활성화 함수:

   • 출력 형태: 동일.
   • 활성화 후 형태: (16, 16, 32)

7. 두 번째 풀링 레이어:

   • 파라미터:
     • 풀 크기 (예: 2x2)
     • 스트라이드 (예: 2)
   • 출력 형태: (8, 8, 32)

8. 평탄화(Flatten) 레이어:

   • 연산: 3D 출력을 1D 벡터로 변환하여 완전 연결 레이어에 입력.
   • 계산:
     • 총 유닛 수 = 높이 x 너비 x 채널 수
     • 총 유닛 수: 8 x 8 x 32 = 2048
   • 출력 형태: (2048,)

9. 완전 연결(Dense) 레이어:

   • 파라미터:
     • 유닛 수 (예: 128개 뉴런)
   • 연산: 입력의 가중합을 계산하여 출력 생성.
   • 출력 형태: (128,)

10. 활성화 함수(ReLU 등):

    • 출력 형태: 동일.
    • 활성화 후 형태: (128,)

11. 출력 레이어:

    • 파라미터:
      • 유닛 수 (예: 클래스 수 만큼, 숫자 0~9를 분류한다면 10)
      • 활성화 함수 (예: 소프트맥스)
    • 출력 형태: (10,)

각 레이어의 상세 설명:

• 합성곱 레이어:

  지역적인 패턴과 특징(에지, 텍스처, 형태 등)을 감지하는 역할을 합니다. 필터가 입력 데이터 위를 슬라이딩하며 요소별 곱셈과 합산(합성곱 연산)을 수행합니다.

• 패딩:

  • 'Same' 패딩: 출력이 입력과 동일한 공간적 차원을 가지도록 입력 주위에 0을 추가.
  • 'Valid' 패딩: 패딩을 사용하지 않으며, 커널 크기에 따라 출력 크기가 감소.

• 스트라이드:

  필터 창이 입력 매트릭스 위를 이동하는 픽셀 수입니다. 스트라이드가 클수록 출력이 작아집니다.

• 활성화 함수:

  비선형성을 도입하여 복잡한 패턴을 학습할 수 있게 합니다. ReLU(Rectified Linear Unit)는 기울기 소실 문제를 완화하여 널리 사용됩니다.

• 풀링 레이어:

  공간적 차원을 줄여 계산량을 감소시키고 과적합을 방지합니다. 대표적인 종류로는 최대 풀링과 평균 풀링이 있습니다.

• 평탄화 레이어:

  다차원 출력을 완전 연결 레이어에 입력하기 위해 1차원 배열로 변환합니다.

• 완전 연결 레이어:

  이전 레이어의 모든 뉴런과 연결되어 있으며, 합성곱 레이어에서 추출된 특징을 기반으로 예측을 수행합니다.

• 출력 레이어:

  최종 출력을 생성합니다. 분류 작업의 경우 소프트맥스 활성화 함수를 사용하여 각 클래스에 대한 확률을 출력합니다.

추가 고려 사항:

• 배치 크기:

  데이터는 일반적으로 배치 단위로 처리됩니다. 배치 크기가 N인 경우 입력과 출력 형태는 (N, 높이, 너비, 채널 수)가 됩니다.

• 컬러 이미지:

  RGB 이미지를 사용하는 경우 초기 입력 형태는 (높이, 너비, 3)입니다.

• 깊은 네트워크:

  VGG, ResNet, Inception과 같은 현대적인 CNN은 더 많은 레이어를 포함하며, 추가적인 합성곱 및 풀링 레이어, 배치 정규화 레이어, 스킵 연결 등을 포함합니다.

• 정규화 기법:

  • 드롭아웃 레이어: 학습 시 무작위로 일부 입력 유닛을 0으로 설정하여 과적합을 방지.
  • 배치 정규화: 미니배치마다 입력을 정규화하여 학습 과정을 안정화.

• RGB 이미지 예시:

  64x64 픽셀의 RGB 이미지를 사용한다고 가정합니다.

  • 입력 형태: (64, 64, 3)

  3x3 크기의 32개 필터를 가진 합성곱 레이어를 통과하면:

  • 출력 형태: (64, 64, 32)

  'Valid' 패딩을 사용하면 공간적 차원이 감소합니다:

  • 출력 높이와 너비: 64 - 3 + 1 = 62
  • 출력 형태: (62, 62, 32)

  풀 크기가 2x2이고 스트라이드가 2인 풀링을 적용하면:

  • 출력 형태: (31, 31, 32)

출력 차원 계산을 위한 수학 공식:

• 합성곱 레이어 출력 차원:

  출력 높이 = (입력 높이 - 커널 높이 + 2 x 패딩) / 스트라이드 + 1
  출력 너비 = (입력 너비 - 커널 너비 + 2 x 패딩) / 스트라이드 + 1

• 풀링 레이어 출력 차원:

  출력 높이 = (입력 높이 - 풀 높이) / 스트라이드 + 1
  출력 너비 = (입력 너비 - 풀 너비) / 스트라이드 + 1

실용적인 팁:

• 커널 크기 선택:

  일반적인 커널 크기는 3x3이나 5x5입니다. 작은 커널은 세부 정보를, 큰 커널은 더 넓은 특징을 포착합니다.

• 네트워크의 깊이:

  레이어 수를 증가시키면 복잡한 특징을 학습할 수 있지만, 과적합 위험과 계산 비용이 증가할 수 있습니다.

• 필터 수:

  일반적으로 깊은 레이어에서는 더 복잡한 특징을 포착하기 위해 필터 수를 증가시킵니다.

• 최적화:

  학습률 스케줄링, 모멘텀, Adam과 같은 적응형 옵티마이저를 사용하여 학습을 개선합니다.

Fully Connected layer의 유닛

• 중간 특징 학습 완전 연결 레이어의 유닛 수는 CNN의 최종 특징을 압축하거나, 학습을 통해 중요한 패턴을 더 잘 잡아내기 위해 설정된 중간 유닛 수입니다. 이 레이어의 유닛 수는 보통 임의로 설정되며, 특정한 특징이나 패턴을 좀 더 잘 학습할 수 있도록 모델을 조정하는 단계입니다.
• 유닛 수 선택 보통 128, 256, 512 등의 유닛 수를 사용하는데, 이는 CNN이 학습한 복잡한 특징을 모아 최종 분류(또는 예측)를 위해 준비하는 역할을 합니다.

prompt: 일반적인 cnn의 구조를 알고싶어. 그리고 구조를 지날 때 input data shape이 어떻게 변화하는지 예시를 들어가며 알려줘. 최대한 길게 많은 내용을 (한국어로) 설명해

*: 포인터 &: 참조자 ::: 범위 지정 연산자 std: 네임 스페이스 .: 멤버 연산자 이렇게 5개의 개념을 중점으로 설명해주셨다.

포인터 (*)

• 메모리 주소를 저장하는 변수

  &: 참조자, 주소 연산자

  &는 두가지 기능이 있다. 문맥상 기능을 나누는 것이 아니라, 컴파일러 자체가 문법적으로 구분하여 각각 다르게 처리함.

  1. 참조자 선언

• 기존 변수를 가리키는 또 다른 이름 (like. 별명)
• 별도의 메모리 주소를 저장하지 않는다.

  int num = 10;    // num이라는 변수를 선언하고 값 10을 저장
  int &ref = num;  // ref는 num의 참조자 (=별명)

  2. 주소 연산자

  int num = 10;
  int *ptr = # // 여기서 &는 변수의 주소를 가져오는 역할

• ptr은 num의 주소를 저장하는 포인터가 된다.
• 이 경우 &는 표현식의 일부로 사용된다. 변수 num의 주소를 얻는 주소 연산자로 해석된다.

예시 코드로 이해하기 - *와 &의 관계

int q=0; // 정수형 변수 `q`르 0으로 초기화
int &a=q; //`q`라는 변수의 참조자인 a를 선언. a가 q를 참조한다. a를 수정하면 q가 바뀌고 q를 수정하면 a도 바뀐다.
int *b= &a; // a의 주소를 포인터 b에 저장. b는 a와 q의 주소를 가리킨다.
int c= *b; // b가 가리키는 값을 역참조하여 c에 저장.

b는 a의 주소를 가리키고, a는 q를 참조하기 때문에 c는 q값을 가지게 된다. 결과적으로 c = 0.

int *z=0;

정수형 포인트z를 nullptr로 초기화. z는 아무것도 가리키지 않음.

다중 포인터

int **d= &b;

• b의 주소를 저장하는 이중 포인터 d를 선언.
• d는 b라는 포인터를 가리키는 포인터

  int ***e  = &d; // e는 b라는 포인터를 가리키는 3중 포인터

  다중 역참조

  c= *(*d);  // d를 두 번 역참조하여 b가 가리키는 값을 가리킨다. (c=0)
  c= *(*(*e)); // e를 세 번 역참조하여 b가 가리키는 값을 가리킨다. (c=0)

  네임 스페이스

• 이름(변수, 함수, 클래스 등)을 구분하기 위해 사용되는 "공간" 또는 "범위
• 여러 코드나 라이브러리에서 같은 이름의 함수나 변수를 사용할 수 있는데, 그때 이름 충돌을 피하기 위해 필요하다.

  namespace std {
    extern ostream cout;   // cout은 표준 출력 스트림(콘솔 출력)과 연결된 ostream 객체
  }

범위 지정 연산자 (::)

• 특정 네임스페이스나 클래스 내에 정의된 함수 또는 변수를 명시적으로 지정할 때 사용
• std::cout: ::는 std네임 스페이스에 속한 cout 객체를 명시

번외 . 연산자

. : 객체의 멤버에 접근할 때 사용하는 연산자.

둘을 구분할 때에

#include <iostream>
#include <string>
namespace aaa{
class anda{
    public:
    void va()
    {

    }

    static va_s()
    {

    }
}
}

namespace std
{
    class anda
    {
        public:
        void va()
        {

        }

        static va_s()
        {

        }
    }

    bool getline(std::ifstream *f, std::string & s)
    {
        int ** d= &b;
        int **** e  = &d;
        c= *(*d);
        c= *(*(*e));

        f->is_open();
        f[0]->is_open();
        *f.is_open();
    }
}

int main() {
    std::ifstream inFile(_T("example.txt"));
    anda::va_s()
    anda a;
    bbb::test()

    a.va()
    if (inFile.is_open()) {
        std::string line;
        while (std::getline(&inFile, line)) {
            std::cout << line << std::endl;
        }
        inFile(1);
    }
}

프로그램이 외부 파일에서 데이터를 읽고, 파일에 데이터를 쓰는 데에 사용된다.

• <fstream> 헤더를 사용

  기본 파일 입출력:

• ifstream: 파일에서 데이터를 읽을 때 사용.
• ofstream: 파일에 데이터를 쓸 때 사용.
• fstream: 파일에서 읽고 쓰는 기능을 모두 사용할 때 사용.

파일에 데이터 쓰기 (ofstream)

#include <iostream>
#include <string>
#include <fstream>  // 파일 입출력을 위한 헤더 파일

int main() {
    std::ofstream outFile("example.txt");  // 파일을 열거나 생성

    if (outFile.is_open()) {  // 파일이 정상적으로 열렸는지 확인
        outFile << "Hello, World!" << std::endl;  // 파일에 데이터 쓰기
        outFile << "This is C++ file handling." << std::endl;
        outFile.close();  // 파일을 닫음
    } else {
        std::cout << "Unable to open file for writing" << std::endl;
    }

    return 0;
}

• outFile("example.txt"): 파일이 없으면 생성되고, 파일이 있으면 덮어쓰기가 .
• outFile << ...: 파일에 데이터를 기록하는 방식은 std::cout과 유사하게 작동해.
• outFile.close(): 파일을 열었으면, 작업이 끝난 후 반드시 닫아줘야 해.

파일에서 데이터 읽기 (ifstream)

#include <iostream>
#include <fstream>

int main() {
    std::ifstream inFile("example.txt");  // 파일을 열어 읽기 모드로

    if (inFile.is_open()) {
        std::string line;
        while (std::getline(inFile, line)) {  // 파일의 각 줄을 읽음
            std::cout << line << std::endl;   // 읽은 내용을 출력
        }
        inFile.close();  // 파일을 닫음
    } else {
        std::cout << "Unable to open file for reading" << std::endl;
    }

    return 0;
}

• std::getline: 파일의 내용을 한 줄씩 읽어들이는 함수.
• inFile.close(): 파일 읽기가 끝나면 파일을 닫아야 함.

파일 입출력 동시에 하기 (fstream)

• 파일을 읽고 쓸 수 있는 양방향 스트림.
• 파일을 열고, 읽고, 쓸 수 있다.

#include <iostream>
#include <fstream>

int main() {
    std::fstream file("example.txt", std::ios::in | std::ios::out);

    if (file.is_open()) {
        file << "Writing some new data." << std::endl;  // 파일에 쓰기

        file.seekg(0);  // 파일 포인터를 다시 처음으로 이동
        std::string line;
        while (std::getline(file, line)) {
            std::cout << line << std::endl;  // 파일에서 읽기
        }

        file.close();  // 파일 닫기
    } else {
        std::cout << "Unable to open file" << std::endl;
    }

    return 0;
}

• std::ios::in | std::ios::out: 읽기와 쓰기를 동시에 하기 위한 모드.
• seekg(0): 파일 포인터를 처음으로 돌려서 파일을 다시 읽기 시작.

연습 문제

1. student.txt 파일을 생성하고, 학생의 이름과 나이를 저장하는 프로그램을 작성해보자.
2. student.txt 파일을 읽어서 파일의 내용을 출력하는 프로그램을 만들어보자.

1. 변환하고 싶은 노션 페이지를 html로 내보내기한다.
2. 파이썬으로 txt 변환한다.

   # 입력 HTML 파일 경로
   title = 'cuda upgrade'
   

from bs4 import BeautifulSoup from bs4.element import NavigableString

def parse_html_to_text(node, depth=0, ol_counters=None, current_heading_level=0): if ol_counters is None: ol_counters = {} result = ''

# 현재 노드가 h1, h2, h3인지 확인하여 들여쓰기 수준 결정
if node.name in ['h1', 'h2', 'h3']:
    indent_level = 0  # 헤딩은 들여쓰기 없음
else:
    indent_level = current_heading_level + 1  # 추가 들여쓰기 적용

indent = '\t' * indent_level

# 헤딩 처리
if node.name in ['h1', 'h2', 'h3']:
    # 헤딩 텍스트 출력
    text = node.get_text(strip=True)
    if text:
        result += f"{text}\n"  # 헤딩은 들여쓰기 없음
    # 현재 헤딩 레벨 갱신
    current_heading_level = int(node.name[1])
# 문단 처리
elif node.name == 'p':
    text = node.get_text(strip=True)
    if text:
        result += f"{indent}{text}\n"
# 순서 있는 목록 처리
elif node.name == 'ol':
    # 현재 깊이의 번호를 초기화하거나 start 속성 사용
    start = node.get('start')
    if start:
        counter = int(start)
    else:
        counter = 1
    ol_counters[depth] = counter

    for li in node.find_all('li', recursive=False):
        result += parse_html_to_text(li, depth, ol_counters, current_heading_level)
    # 목록 종료 시 카운터 삭제
    del ol_counters[depth]
# 순서 없는 목록 처리
elif node.name == 'ul':
    for li in node.find_all('li', recursive=False):
        result += parse_html_to_text(li, depth, ol_counters, current_heading_level)
# 목록 아이템 처리
elif node.name == 'li':
    # 목록 아이템의 들여쓰기는 헤딩 레벨과 깊이에 따라 결정
    item_indent_level = indent_level + depth
    item_indent = '\t' * item_indent_level

    if node.parent.name == 'ol':
        number = ol_counters.get(depth, 1)
        ol_counters[depth] = number + 1
        bullet = f"{number}. "
    else:
        bullet = "- "

    # 아이템의 텍스트 내용 추출
    item_text = ''
    for child in node.contents:
        if isinstance(child, NavigableString):
            item_text += child.strip()
        elif child.name not in ['ol', 'ul']:
            item_text += child.get_text(strip=True)

    result += f"{item_indent}{bullet}{item_text}\n"

    # 자식 요소 재귀 처리
    for child in node.contents:
        if child.name in ['ul', 'ol']:
            result += parse_html_to_text(child, depth + 1, ol_counters, current_heading_level)
# 코드 블록 처리
elif node.name == 'pre':
    code_text = node.get_text()
    lines = code_text.split('\n')
    for line in lines:
        if line.strip():  # 빈 줄은 무시
            result += f"{indent}{line}\n"
        else:
            result += "\n"
# 불필요한 요소 필터링
elif node.name in ['figure', 'img', 'style', 'script']:
    pass  # 해당 요소는 무시
# 텍스트 노드 처리
elif isinstance(node, NavigableString):
    text = node.strip()
    if text:
        result += f"{indent}{text}\n"
# 기타 요소 처리
else:
    for child in node.children:
        result += parse_html_to_text(child, depth, ol_counters, current_heading_level)

return result

입력 HTML 파일 경로

input_file = title + '.html'

출력 텍스트 파일 경로

output_file = title + '.txt'

HTML 파일 읽기

with open(input_file, 'r', encoding='utf-8') as f: html_content = f.read()

BeautifulSoup으로 파싱

soup = BeautifulSoup(html_content, 'html.parser')

body 태그 선택

body = soup.find('body')

텍스트 변환 실행

text_output = parse_html_to_text(body)

결과를 텍스트 파일로 저장

with open(output_file, 'w', encoding='utf-8') as f: f.write(text_output)

print(f"변환이 완료되었습니다. 결과는 '{output_file}'에 저장되었습니다.")

3. python으로 txt를 pptx로 변환한다.
```python
from pptx import Presentation
from pptx.util import Inches, Pt
import re

# 입력 텍스트 파일 경로
input_txt_file = output_file

# 출력 PPTX 파일 경로
output_pptx_file = title + '.pptx'

# 프레젠테이션 객체 생성
prs = Presentation()

# 슬라이드 크기를 와이드스크린(16:9)으로 설정
prs.slide_width = Inches(13.33)
prs.slide_height = Inches(7.5)

# 텍스트 파일 읽기
with open(input_txt_file, 'r', encoding='utf-8') as f:
    lines = f.readlines()

# 1. 첫 장에 제목 슬라이드 추가 (slide_layouts[0] 사용)
title_slide_layout = prs.slide_layouts[0]  # 제목 슬라이드 레이아웃
title_slide = prs.slides.add_slide(title_slide_layout)

# 첫 번째 줄을 제목으로 사용
first_line = lines[0].strip()  # 첫 번째 줄에서 개행 문자 제거

# 제목과 부제목 설정
title = title_slide.shapes.title
title.text = first_line  # 첫 번째 줄을 제목으로 설정

# 이후 슬라이드 레이아웃 선택 (제목 및 내용)
slide_layout = prs.slide_layouts[1]

current_slide = None
bullet_levels = []

for i, line in enumerate(lines):  
    stripped_line = line.strip('\n')
    # 들여쓰기 수준 계산
    indent_level = len(re.match(r'^(\t*)', stripped_line).group(1))
    content = stripped_line.lstrip('\t')

    if i == 0:
        # 첫 번째 슬라이드는 이미 제목으로 사용했으므로 건너뜀
        continue

    # 헤딩인지 확인 (h1, h2, h3는 들여쓰기 없음)
    if indent_level == 0:
        # 새로운 슬라이드 생성
        current_slide = prs.slides.add_slide(slide_layout)
        title_placeholder = current_slide.shapes.title
        body_placeholder = current_slide.placeholders[1]
        tf = body_placeholder.text_frame
        tf.clear()

        # 두 번째 슬라이드의 제목도 첫 번째 줄을 사용
        title_placeholder.text = first_line if i == 1 else content
        bullet_levels = []
    else:
        if current_slide is None:
            # 슬라이드가 없으면 새로 생성
            current_slide = prs.slides.add_slide(slide_layout)
            body_placeholder = current_slide.placeholders[1]
            tf = body_placeholder.text_frame
            tf.clear()
        else:
            body_placeholder = current_slide.placeholders[1]
            tf = body_placeholder.text_frame

        # 리스트 아이템인지 확인
        bullet_match = re.match(r'^(- |\d+\. )(.*)', content)
        if bullet_match:
            bullet_text = bullet_match.group(2)
            p = tf.add_paragraph()
            p.text = bullet_text
            p.level = indent_level - 1  # 들여쓰기 수준에 따라 bullet level 설정
        else:
            # 일반 텍스트
            p = tf.add_paragraph()
            p.text = content
            p.level = indent_level - 1  # 들여쓰기 수준에 따라 bullet level 설정

# 프레젠테이션 저장
prs.save(output_pptx_file)

print(f"텍스트 파일이 '{output_pptx_file}'로 변환되었습니다.")

4. power point에서 pptx 열고 회사 템플릿을 불러온다.

코드 더 수정해야지... 아직 태그에 종속적인 코드다.

개선점

1. 코드 부분이 삭제됨
2. 이미지 넣기 안됨
3. 프로그램 (exe) 형식으로 만들기

class: 클래스를 정의할 때 사용하는 키워드. public: 외부에서 접근 가능한 멤버 지정. - 클래스 내부에서만 사용할 멤버는 private으로 설정할 수 있다.

멤버 함수: 클래스 내부에 포함된 함수. 데이터를 처리하는 로직을 포함

#include <iostream>

class Person {
public:
    std::string name;
    int age;
    char gender;

    // 멤버 함수
    void introduce() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

int main() {
    // 클래스 객체 선언
    Person p1;

    // 객체 멤버 변수에 값 대입
    p1.name = "Alice";
    p1.age = 30;
    p1.gender = 'F';

    // 멤버 함수 호출
    p1.introduce();

    return 0;
}

연습문제

1. 구조체를 사용해 학생 정보를 저장하고 출력하는 프로그램을 만들어보자. 학생의 이름, 나이, 학년을 저장하도록 하자.
2. 클래스를 사용해 간단한 Car 클래스를 만들어보자. Car 클래스는 모델명, 연식, 그리고 출력을 담당하는 멤버 함수를 가지도록 해보자.

// 1.
#include <iostream>
#include <string>  // 문자열을 사용하기 위해 포함

struct Student {
    std::string name;  // str -> std::string
    int age;
    int grade;
};

int main() {
    Student s1;
    s1.name = "Alice";
    s1.age = 16;
    s1.grade = 10;

    std::cout << "Name: " << s1.name << std::endl;
    std::cout << "Age: " << s1.age << std::endl;
    std::cout << "Grade: " << s1.grade << std::endl;

    return 0;
}

// 2.
#include <iostream>
#include <string>

class Car {
public:
    std::string name;  // 모델명
    int age;  // 연식

    // 멤버 함수
    void introduce() {
        std::cout << "This car's name is " << name << " and it is " << age << " years old." << std::endl;
    }
};

int main() {
    Car car1;
    car1.name = "Toyota";
    car1.age = 5;

    car1.introduce();

    return 0;
}

생성자 (Constructor)

객체가 생성될 때 자동으로 호출되는 함수. 객체의 멤버 변수를 초기화하는 역할. 클래스 이름과 동일한 이름을 가지고 반환형이 없다.

• 파이썬에서 __init__과 같은 역할

  class Person {
  public:
    std::string name;
    int age;
  
    // 생성자
    Person() {
        name = "Unknown";
        age = 0;
    }
  
    void introduce() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
  };
  

int main() { Person p1; // 생성자가 자동으로 호출되어 name과 age가 초기화됨 p1.introduce(); return 0; }

# 매개변수를 받는 생성자

매개변수: 객체의 멤버 변수를 초기화하기 위한 값.
```ccp
class Person {
public:
    std::string name;
    int age;

    // 매개변수 생성자
    Person(std::string n, int a) {
        name = n;
        age = a;
    }

    void introduce() {
        std::cout << "Hello, my name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

같은 기능 파이썬에서 구현:

class Person:
    # 매개변수 생성자
    def __init__(self, name, age):
        self.name = name  # 매개변수 name을 멤버 변수 self.name에 저장
        self.age = age    # 매개변수 age를 멤버 변수 self.age에 저장

    def introduce(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

소멸자 (Destructor)

• 객체가 삭제될 때 자동으로 호출되는 함수

• 동적으로 할당된 메모리를 해제할 때 사용

• 클래스 이름 앞에 ~를 붙여서 정의

• 반환형x, 매개변수x

  class Person {
  public:
    std::string name;
  
    // 생성자
    Person(std::string n) {
        name = n;
        std::cout << name << " is created." << std::endl;
    }
  
    // 소멸자
    ~Person() {
        std::cout << name << " is destroyed." << std::endl;
    }
  };
  

int main() { Person p1("Alice"); // 프로그램이 끝날 때 p1의 소멸자가 자동으로 호출됨 return 0; }

## 연습 문제
1. 매개변수 생성자를 사용해 Student 클래스를 만들어보자. Student는 이름과 학년을 가지며, 학생의 정보를 출력하는 멤버 함수를 포함해야 해.
2. 소멸자를 사용해 Car 클래스에 소멸자가 호출될 때 "Car is being destroyed"라는 메시지를 출력하도록 만들어보자.

```cpp
#include <iostream>

class Student {
public:
    std::string name;
    int grade;

    // 매개변수 생성자
    Student(std::string n, int g) {
        name = n;
        grade = g;
    }

    // 멤버 함수
    void introduce() {
        std::cout << "Name: " << name << ", Grade: " << grade << std::endl;
    }

    // 소멸자
    ~Student() {
        std::cout << name << " is being destroyed." << std::endl;
    }
};

int main() {
    // 객체 생성
    Student s1("Alice", 26);

    // 객체의 멤버 함수 호출
    s1.introduce();

    return 0;
}

상속

부모 클래스의 기능을 자식 클래스가 물려받아 확장하거나 수정할 수 있는 기능

상속의 기본 구조

class Parent {
public:
    void speak() {
        std::cout << "I am the parent." << std::endl;
    }
};

class Child : public Parent {
public:
    void introduce() {
        std::cout << "I am the child." << std::endl;
    }
};

int main() {
    Child c;
    c.speak();  // 부모 클래스의 함수 호출
    c.introduce();  // 자식 클래스의 함수 호출
    return 0;
}

다형성(Polymorphism)

• 같은 함수를 여러 가지 방식으로 구현하는 능력 부모 클래스에서 정의된 함수를 자식 클래스가 재정의(override)할 수 있다.

Virtual: 함수 재정의

• 부모 클래스 앞에 virtual 키워드를 붙이면, 자식 클래스에서 그 함수를 재정의할 수 있다.
• 재정의된 함수는 부모 클래스의 포인터나 참조를 통해 호출되더라도 자식 클래스의 동작을 따르게 된다.

class Parent {
public:  // 외부에서 클래스의 멤버 변수나 함수에 접근하고 싶을 때 사용
    virtual void speak() {  // 가상 함수
        std::cout << "I am the parent." << std::endl;
    }
};

class Child : public Parent {
public:
    void speak() override {  // 함수 재정의
        std::cout << "I am the child." << std::endl;
    }
};

int main() {
    Parent* p = new Child();  // 부모 클래스 포인터가 자식 클래스를 가리킴.
    p->speak();  // 자식 클래스의 speak 함수가 호출됨

    delete p;  // 동적 메모리 해제
    return 0;
}

virtual과 override

만약 Child 클래스에서 함수를 재정의할 때 virtual과 override가 없다면? 부모 클래스의 포인터나 참조로 자식 객체를 가리킬 때 부모 클래스의 함수가 호출된다. 즉, 부모 클래스의 speak() 함수가 호출되고, 자식 클래스의 speak() 함수는 무시된다.

포인터 사용 이유

다형성을 사용하려면 부모 클래스의 포인터 또는 참조를 통해 자식 클래스 객체에 접근해야 한다. 포인터를 사용하지 않으면 정적 바인딩이 이뤄진다. 즉, 컴파일 타임에 어느 함수가 호출될지 결정된다. = 해당 클래스의 함수만 사용할 수 있고 재정의된 함수는 호출되지 않는다.

동적 메모리 해제

• new로 동적 할당한 메모리는 반드시 delete로 해제해야 함.

delete p;가 없으면: 동적으로 할당된 메모리가 해제되지 않아 메모리 누수(memory leak) 가 발생 -> 프로그램의 메모리 사용량이 계속 증가하여 시스템 성능이 저하

연습 문제

1. 상속을 사용해 Animal 클래스를 만들고, Dog와 Cat 클래스를 상속받아 각각 다른 소리를 내는 speak 함수를 구현해보자.
2. 다형성을 사용해 Animal 클래스의 speak 함수를 Dog와 Cat에서 재정의하고, 부모 클래스 포인터를 통해 각각의 speak 함수가 호출되는 프로그램을 만들어보자.

#include <iostream>

class Animal {
public:
    virtual void sound() {  // 가상 함수
        std::cout << "sound sample" << std::endl;
    }
};

class Dog: public Animal {
public:
    void sound() override {  // 함수 재정의
        std::cout << "Bark" << std::endl;
    }
};

class Cat: public Animal {
public:
    void sound() override {  // 함수 재정의
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Animal* p1 = new Dog;
    Animal* p2 = new Cat;

    // 함수 호출
    p1->sound();  // Dog의 sound 함수 호출
    p2->sound();  // Cat의 sound 함수 호출

    // 동적 메모리 해제
    delete p1;
    delete p2;

    return 0;
}

추상 클래스 (Abstract Class)

• 한 개 이상의 순수 가상 함수를 포함하는 클래스
• 여러 클래스를 그룹화 하기 위해 생성한다.

  순수 가상 함수

• 함수 자체에 구현이 없는 가상 함수

class Animal {
public:
    virtual void sound() = 0;  // 순수 가상 함수
};

class Dog : public Animal {
public:
    void sound() override {
        std::cout << "Bark" << std::endl;
    }
};

class Cat : public Animal {
public:
    void sound() override {
        std::cout << "Meow" << std::endl;
    }
};

int main() {
    Animal* p1 = new Dog;
    Animal* p2 = new Cat;

    p1->sound();  // Dog의 sound 호출
    p2->sound();  // Cat의 sound 호출

    delete p1;
    delete p2;

    return 0;
}

인터페이스 (Interface)

인터페이스(추상 클래스)란?

공통된 기능을 정의하지만, 그 기능의 구체적인 구현은 포함하지 않는 클래스

파이썬에서 추상 클래스를 사용한 인터페이스 예시:

class Shape:
    def area(self):
        pass  # 공통 인터페이스 역할만, 실제 구현 없음

# Circle 클래스 (Shape 상속)
class Circle(Shape):
    def __init__(self, r):
        self.r = r

    def area(self):
        return 3.14 * self.r * self.r

# Rectangle 클래스 (Shape 상속)
class Rectangle(Shape):
    def __init__(self, w, h):
        self.w = w
        self.h = h

    def area(self):
        return self.w * self.h

# 메인 함수
def main():
    # Rectangle 객체 생성
    rec = Rectangle(3, 4)
    print("Area of rectangle:", rec.area())

    # Circle 객체 생성
    circ = Circle(5)
    print("Area of circle:", circ.area())

if __name__ == "__main__":
    main()

추상 메서드란?

• 인터페이스에서 선언된 메서드
• 구현이 없이 선언만 되어 있는 메서드
• 파이썬에서는 pass를 사용

위 코드에서 Shape 클래스는 추상 클래스입니다. area 메소드는 구현되어 있지 않고, 추상 메소드로 선언되어 있습니다. 따라서, 이 클래스를 직접 인스턴스화 할 수 없으며, 이 클래스를 상속받아 구현된 클래스를 사용해야 합니다. Circle 클래스와 Rectangle 클래스는 Shape 클래스를 상속받아서 만들어진 구체적인 도형 클래스입니다. 이들 클래스는 Shape 클래스에서 정의한 move 메소드를 사용할 수 있고, area 메소드를 구체적으로 구현하여 각 도형의 면적을 계산할 수 있습니다. 이러한 추상화를 통해, 각 도형의 공통된 속성과 기능을 효율적으로 관리할 수 있고, 필요에 따라 도형 클래스를 상속받아서 새로운 도형을 추가할 수 있습니다. C++에서는 인터페이스라는 개념이 별도로 존재하지는 않지만, 이를 구현하는 방법은 순수 가상 함수만을 포함하는 추상 클래스를 정의하는 방식이다. 인터페이스는 오직 함수의 선언만 포함하고, 구현은 자식 클래스에서 이루어지게끔 만든다.

cpp:

class IShape {
public:
    virtual void draw() = 0;
    virtual double area() = 0;
};

class Circle : public IShape {
public:
    void draw() override {
        std::cout << "Drawing Circle" << std::endl;
    }

    double area() override {
        return 3.14 * radius * radius;
    }

private:
    double radius = 5.0;
};

class Rectangle : public IShape {
public:
    void draw() override {
        std::cout << "Drawing Rectangle" << std::endl;
    }

    double area() override {
        return width * height;
    }

private:
    double width = 4.0;
    double height = 6.0;
};

int main() {
    IShape* shape1 = new Circle;
    IShape* shape2 = new Rectangle;

    shape1->draw();
    std::cout << "Area: " << shape1->area() << std::endl;

    shape2->draw();
    std::cout << "Area: " << shape2->area() << std::endl;

    delete shape1;
    delete shape2;

    return 0;
}

추상 클래스를 직접 객체로 생성하면 에러가 뜬다.

#include <iostream>
class IShape {
public:
    virtual void draw() = 0;  // 순수 가상 함수
};

int main() {
    IShape shape;  // 에러 발생: 추상 클래스의 객체는 생성 불가능
    return 0;
}

// 에러 메세지:
main.cpp: In function ‘int main()’:
main.cpp:16:12: error: cannot declare variable ‘shape’ to be of abstract type ‘IShape’
   16 |     IShape shape;  // 에러 발생: 추상 클래스의 객체는 생성 불가능
      |            ^~~~~

연습 문제

1. 추상 클래스를 사용해 Vehicle 클래스를 만들고, 이를 상속받는 Car와 Bike 클래스를 정의해보자. 각 클래스는 move() 함수를 구현해야 해.
2. 인터페이스를 사용해 Shape 인터페이스를 만들고, 이를 구현하는 Square와 Triangle 클래스를 만들어 각각의 넓이를 구하는 함수를 구현해보자.

// 1번
#include <iostream>

class Vehicle {
public:
    virtual void move() = 0;
};

class Bike : public Vehicle {
public:
    void move() override { 
        std::cout << "beep beep" << std::endl;
    }
};

class Car : public Vehicle {
public:
    void move() override { 
        std::cout << "ding-ding" << std::endl;
    }
};

int main() {
    Vehicle* veh1 = new Car;
    Vehicle* veh2 = new Bike;

    std::cout << "Car sound: ";
    veh1->move();  // Car의 move 함수 호출

    std::cout << "Bike sound: ";
    veh2->move();  // Bike의 move 함수 호출

    delete veh1;
    delete veh2;

    return 0;
}

// 2번
#include <iostream>

// 추상 클래스 Shape
class Shape {
public:
    virtual double area(double l) = 0;  // 순수 가상 함수
};

// Square 클래스, Shape 상속
class Square : public Shape {
public:
    double area(double l) override {  // 함수 재정의
        return l * l;
    }
};

// Triangle 클래스, Shape 상속
class Triangle : public Shape {
public:
    double area(double l) override {  // 함수 재정의
        return (l * l) / 2;
    }
};

int main() {
    Shape* shape1 = new Square;
    Shape* shape2 = new Triangle;

    double l = 4.0;

    // Square의 area 함수 호출
    std::cout << "Square area: " << shape1->area(l) << std::endl;

    // Triangle의 area 함수 호출
    std::cout << "Triangle area: " << shape2->area(l) << std::endl;

    delete shape1;
    delete shape2;

    return 0;
}

• 의료 영상 분할(Semantic Segmentation)을 위한 딥러닝 모델로 2015년에 개발됨.
• 오토인코더(autoencoder)와 같은 인코더-디코더(encoder-decoder) 기반 모델
  • 근데 이제 스킵 연결이 추가된..

UNet의 구조

개요

• 인코딩(압축)과 디코딩(복원) 과정을 거치는 U자형 구조.
• 인코딩 단계에서 이미지를 점점 작게 만들면서 중요한 특징을 추출하고, 디코딩 단계에서 다시 그 특징을 기반으로 원래 이미지와 비슷하게 복원한다.

채널 수, 이미지 크기의 변화를 이해하기 위해 gpt에게 물어봤음.

Forward 과정에서의 변화

1. 입력 (x):
   • 채널 수: 3 (RGB 이미지)
   • 차원 수: 2차원 이미지 (너비 × 높이) MaxPool2d와 Conv2d 함수로 2차원 데이터 임을 짐작할 수 있음.
   • 특징 수: x
   • 이미지 크기: 입력 이미지 크기 (예: 256×256)

인코딩 (Downsampling)

2. Conv1 (첫 번째 Conv Block):

   • 채널 수: 3 → 64 (64개의 필터 사용)
   • 차원 수: 그대로 (2D 이미지)
   • 특징 수: 64개의 특징 맵이 생성됨.
   • 이미지 크기: 256×256 (입력 크기 유지)

3. MaxPool:

   • 채널 수: 그대로 (64)
   • 차원 수: 그대로
   • 이미지 크기: 256×256 → 128×128 (풀링으로 크기 절반 감소)

4. Conv2 (두 번째 Conv Block):

   • 채널 수: 64 → 128 (128개의 필터 사용)
   • 차원 수: 그대로
   • 특징 수: 128개의 특징 맵이 생성됨.
   • 이미지 크기: 128×128 유지

5. MaxPool:

   • 채널 수: 그대로 (128)
   • 차원 수: 그대로
   • 이미지 크기: 128×128 → 64×64

6. Conv3 (세 번째 Conv Block):

   • 채널 수: 128 → 256
   • 특징 수: 256개의 특징 맵 생성.
   • 이미지 크기: 64×64 유지

7. MaxPool:

   • 채널 수: 그대로 (256)
   • 이미지 크기: 64×64 → 32×32

8. Conv4 (네 번째 Conv Block):

   • 채널 수: 256 → 512
   • 이미지 크기: 32×32 유지

디코딩 (Upsampling)

9. Up4:

   • 채널 수: 512 → 256
   • 이미지 크기: 32×32 → 64×64 (업샘플링으로 이미지 크기 복원)

10. Concatenation:

    • 채널 수: 256 + 256 → 512 (업샘플된 것과 Conv3 결과를 결합)
    • 이미지 크기: 64×64 유지

11. Up_conv4:

    • 채널 수: 512 → 256
    • 이미지 크기: 64×64 유지

12. Up3:

    • 채널 수: 256 → 128
    • 이미지 크기: 64×64 → 128×128

13. Concatenation:

    • 채널 수: 128 + 128 → 256 (Conv2 결과와 결합)
    • 이미지 크기: 128×128 유지

14. Up_conv3:

    • 채널 수: 256 → 128
    • 이미지 크기: 128×128 유지

15. Up2:

    • 채널 수: 128 → 64
    • 이미지 크기: 128×128 → 256×256

16. Concatenation:

    • 채널 수: 64 + 64 → 128 (Conv1 결과와 결합)
    • 이미지 크기: 256×256 유지

17. Up_conv2:

    • 채널 수: 128 → 64
    • 이미지 크기: 256×256 유지

18. Conv_1x1:

    • 채널 수: 64 → 1 (출력 채널)
    • 이미지 크기: 256×256 유지

UNet 코드 flow

class U_Net(nn.Module):
    def __init__(self, img_ch=3, output_ch=1):
        super(U_Net, self).__init__()

        self.MaxPool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.Conv1 = conv_block(ch_in=img_ch, ch_out=64)
        self.Conv2 = conv_block(ch_in=64, ch_out=128)
        self.Conv3 = conv_block(ch_in=128, ch_out=256)
        self.Conv4 = conv_block(ch_in=256, ch_out=512)
        self.Up4 = up_conv(ch_in=512, ch_out=256)
        self.Up_conv4 = conv_block(ch_in=512, ch_out=256)
        self.Up3 = up_conv(ch_in=256, ch_out=128)
        self.Up_conv3 = conv_block(ch_in=256, ch_out=128)
        self.Up2 = up_conv(ch_in=128, ch_out=64)
        self.Up_conv2 = conv_block(ch_in=128, ch_out=64)
        self.Conv_1x1 = nn.Conv2d(64, output_ch, kernel_size=1, stride=1, padding=0)

    def forward(self, x):
        # encoding path
        x1 = self.Conv1(x)
        x2 = self.MaxPool(x1)

        x2 = self.Conv2(x2)
        x3 = self.MaxPool(x2)

        x3 = self.Conv3(x3)
        x4 = self.MaxPool(x3)

        x4 = self.Conv4(x4)
        d4 = self.Up4(x4)
        d4 = torch.cat((x3, d4), dim=1)

        d4 = self.Up_conv4(d4)
        d3 = self.Up3(d4)
        d3 = torch.cat((x2, d3), dim=1)

        d3 = self.Up_conv3(d3)
        d2 = self.Up2(d3)
        d2 = torch.cat((x1, d2), dim=1)

        d2 = self.Up_conv2(d2)
        net = self.Conv_1x1(d2)
        return net

conv_block: 여러 개의 Convolution layer를 사용하는 블록 up_conv: 디코딩 단계에서 이미지 크기를 복원(업샘플링)

Mermaid 다이어그램

con_block

class conv_block(nn.Module):
    def __init__(self, ch_in, ch_out):
        super(conv_block, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(ch_in, ch_out, kernel_size=3, stride=1, padding=1, bias=True),
            nn.LeakyReLU(inplace=True),
            nn.Conv2d(ch_out, ch_out, kernel_size=3, stride=1, padding=1, bias=True),
            nn.LeakyReLU(inplace=True)
        )

    def forward(self, x):
        x = self.conv(x)
        return x

구조

• (3x3 convolution layer + LeakyReLU 활성화 함수 )패턴이 2중으로 구성됨.

up_conv

class up_conv(nn.Module):
    def __init__(self, ch_in, ch_out):
        super(up_conv, self).__init__()
        self.up = nn.Sequential(
            nn.Upsample(scale_factor=2),
            nn.Conv2d(ch_in, ch_out, kernel_size=3, stride=1, padding=1, bias=True),
            # nn.LeakyReLU(inplace=True)
            nn.ReLU(inplace=True)
        )

    def forward(self, x):
        x = self.up(x)
        return x

구조

1. 업샘플링 nn.Upsample(scale_factor=2): 이미지의 크기를 2배로 확대

   • 원래 이미지가 64×64라면, 업샘플링 후 128×128가 된다.

2. 3x3 convolution layer 1개 nn.Conv2d(ch_in, ch_out, kernel_size=3, stride=1, padding=1)

3. ReLU 활성화 함수 nn.ReLU(inplace=True)

이미지 참고

인코딩 (Encoding)

• 인코딩은 입력 데이터를 압축해서 중요한 특징만 남기는 과정
• 이미지를 인코딩 시, 이미지 전체를 다 사용하지 않고 중요한 부분만 추출 주로 데이터를 더 작은 공간에 표현하려고 사용

  디코딩 (Decoding)

• 인코딩된 데이터를 다시 원래의 형식으로 복원하는 과정.
• 주로 이미지를 복원하거나 텍스트를 다시 재생성할 때 사용.

  순전파 (Forward Propagation)

• 입력 데이터가 인공 신경망을 통과하면서 계산되는 과정
• 입력이 첫 번째 층에서 시작해 마지막 층까지 이동하면서 각 층에서 계산이 일어남. 이 과정에서 예측 결과를 얻는다.
• 네트워크가 데이터를 '어떻게' 처리하는지를 알려주는 과정.

  역전파 (Backpropagation)

• 모델의 예측이 실제 답과 얼마나 차이가 나는지 계산한 후, 그 차이를 줄이기 위해 가중치를 조정하는 과정
• 순전파로 나온 예측과 실제 값 사이의 오류를 바탕으로, 신경망의 가중치를 뒤로 되돌아가면서 조금씩 수정하고, 모델이 점점 더 정확한 예측을 함.

정리

인코딩 (Encoding)

입력 데이터 → 압축, 중요한 특징 추출, 작은 공간 표현.

디코딩 (Decoding)

압축된 데이터 → 원래 형식으로 복원.

순전파 (Forward Propagation)

입력 데이터 → 신경망 통과, 예측 결과 계산.

역전파 (Backpropagation)

예측값과 실제 값 차이 → 가중치 조정, 오류 수정

Mermaid는 코드만으로 복잡한 다이어그램을 쉽게 만들 수 있는 강력한 도구다. Markdown과 같은 텍스트 기반 도구들과 결합하면 더욱 효과적으로 기술 문서와 다이어그램을 작성할 수 있다. 위 사진은 https://mermaid.live/ 에서 코드의 흐름을 다이어그램으로 뽑은 결과다.

GPT로 Mermaid 코드 생성하기

~~ 위 코드의 진행 흐름을 mermaid.live에서 사용가능한 flowchart 코드로 작성해줘

이렇게 프롬프트를 구성하면 된다.

Markdown에서 사용하기

GitHub, GitLab, Notion과 같은 플랫폼에서 직접 Mermaid 코드를 사용해 다이어그램을 그릴 수 있다.

```mermaid flowchart TD A[Start] --> B[Step 1] B --> C[Step 2] C --> D[End] ```

노션에 mermaid를 바로 그려주는 기능이 있다. 코드 이해하기에 정말 도움이 된다. 모두모두 이용하시길~

사용 예시:

참고: https://dawonny.tistory.com/437

6. 한번 더 비밀번호 입력

비밀번호 없이 접속하는 법 pdf 보고 빨리 적용시키자~

모델의 성능을 향상시키기 위해 기존 데이터를 변형하여 새로운 데이터를 생성하는 기법. 주로 딥러닝에서 모델의 일반화 성능을 높이고 과적합(overfitting)을 방지하기 위해 사용된다.

1. 데이터 증강의 필요성

• 딥러닝 모델은 많은 데이터를 필요로 하지만 데이터 수가 부족할 때, 모델이 과적합하는 문제가 발생할 수 있다.

  과적합: 모델이 훈련 데이터에 너무 특화되어 새로운 데이터에 대한 성능이 떨어지는 현상

• 이 문제를 해결하기 위해, 데이터 증강을 사용한다. 기존 데이터를 조금씩 변형해서 더 많은 데이터를 생성하고, 모델이 더 다양한 상황을 학습할 수 있다.

2. 대표적인 데이터 증강 방법

1) 회전 (Rotation)

angle_rand = random.choice([0, 90, 180, 270])

• 이미지 전체를 0도, 90도, 180도, 270도 중 하나의 각도로 무작위 회전.
• 회전을 통해 모델이 다양한 방향에서 이미지를 학습할 수 있게 함.
• 같은 이미지라도 회전된 버전을 학습함으로써, 객체의 방향에 관계없이 모델이 인식할 수 있도록 한다.

2) 평행 이동 (Translation)

trans_rand = [random.uniform(0, 0.3), random.uniform(0, 0.3)]

• 이미지를 x축과 y축 방향으로 무작위로 이동.
• 평행 이동은 객체가 이미지의 중앙에만 위치하는 것이 아니라, 다양한 위치에서도 모델이 인식할 수 있도록 도와준다.
• 객체가 이미지의 한쪽 구석에 있어도 모델이 이를 인식하도록 하는데 유용.

3) 크기 조정 (Scaling)

scale_rand = random.uniform(0.8, 1.2)

• 이미지를 0.8배에서 1.2배 크기로 조정.
• 이는 객체의 크기가 다른 상황을 모델이 학습할 수 있도록 도와준다. 예를 들어, 같은 물체라도 멀리 있을 때는 작고 가까이 있을 때는 크게 보일 수 있다. 이 변형을 통해 모델이 다양한 크기의 객체를 학습할 수 있게 된다.

4) 수평/수직 반전 (Horizontal/Vertical Flip)

hori_rand = random.choice([True, False])
verti_rand = random.choice([True, False])

• 이미지를 좌우로 뒤집거나(수평 반전) 위아래로 뒤집는(수직 반전) 방식.
• 이런 반전 작업을 통해, 같은 이미지를 다양한 방향으로 모델이 학습할 수 있다. 예를 들어, 사람의 얼굴이 좌우 반전되거나 상하 반전된 경우에도 모델이 이를 인식할 수 있다.

5) 색상 조정 (Color Jitter)

transforms.ColorJitter(
    brightness=random.random(),
    contrast=random.random(),
    saturation=random.random(),
    hue=random.random() / 2
)

• 이미지의 밝기, 대비, 채도, 색조를 무작위로 변경.
• 이 변형을 통해 모델이 조명 조건이 다른 다양한 환경에서 이미지를 학습할 수 있도록 도와준다.

3. 데이터 증강의 효과

• 데이터 다양성 증가: 데이터 증강을 통해 기존 데이터에서 여러 변형된 버전을 생성하므로, 데이터셋의 크기를 늘리는 효과를 얻을 수 있다.
• 과적합 방지: 데이터 증강으로 다양한 변형된 데이터를 학습하게 하여, 특정 데이터 패턴에 의존하는 모델을 방지하고 일반화 성능을 높일 수 있다.
• 훈련 데이터 부족 해결: 데이터 수가 부족할 때, 데이터 증강을 통해 더 많은 데이터를 학습할 수 있다. 이는 모델 성능 향상에 큰 도움이 된다.

4. 데이터 증강의 구현 예시

transforms.Compose를 사용해 변형을 차례대로 묶어 적용한다.

• Affine()을 통해 회전, 평행 이동, 크기 조정을 적용하고,
• RandomHorizontalFlip()과 RandomVerticalFlip()으로 좌우, 상하 반전을 무작위로 적용한다.
• ColorJitter()를 사용해 밝기와 색상 변화를 주고, ToTensor()로 이미지를 텐서로 변환해 모델에 입력할 수 있게 만들어.

함수를 호출할 때, 파이썬에서는 값만 넘겨줬지만, C++에서는 포인터를 사용해서 변수의 주소를 넘겨줄 수 있다. 이렇게 하면 함수가 변수를 직접 수정할 수 있다.

#include <iostream>

void changeValue(int* ptr) {
    *ptr = 20;  // 포인터를 이용해 변수의 값을 수정
}

int main() {
    int a = 10;
    std::cout << "Before: " << a << std::endl;

    changeValue(&a);  // a의 주소를 함수에 넘김
    std::cout << "After: " << a << std::endl;

    return 0;
}

changeValue(&a): 변수 a의 주소를 함수에 넘겨줌. *ptr = 20;: 함수 안에서 포인터를 통해 변수 a의 값을 변경.

파이썬에서는

a=10
a=20

이렇게 덮어쓸 수 있었는데 c++은 상당히 복잡하다.

2. 동적 메모리 할당

C++에서는 동적 메모리 할당을 통해 런타임에 메모리를 할당하고 사용해야 한다. 동적 메모리는 프로그램 실행 중에 메모리가 필요할 때 할당하고, 다 사용하면 해제하는 방식으로 사용한다. 이를 통해 배열의 크기를 실행 중에 동적으로 정할 수 있다.

동적 메모리 할당의 문법: new: 메모리를 동적으로 할당. delete: 동적으로 할당한 메모리를 해제.

#include <iostream>

int main() {
    // 동적 메모리 할당
    int* ptr = new int;  // 정수형 변수를 위한 메모리 할당
    *ptr = 10;  // 동적 메모리 공간에 값 할당
    std::cout << "Value: " << *ptr << std::endl;

    // 메모리 해제
    delete ptr;  // 동적으로 할당된 메모리 해제

    return 0;
}

동적 배열 할당 예시

#include <iostream>

int main() {
    int size;
    std::cout << "Enter the size of the array: ";
    std::cin >> size;

    // 동적으로 배열 할당
    int* arr = new int[size];

    // 배열에 값 입력 및 출력
    for (int i = 0; i < size; i++) {
        arr[i] = i * 2;
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    // 배열 메모리 해제
    delete[] arr;  // 동적으로 할당된 배열 메모리 해제

    return 0;
}

연습 문제

함수에서 포인터를 사용해 두 변수의 값을 서로 바꾸는 프로그램을 만들어보자.

#include <iostream>


void swap(int* ptr1, int* ptr2) {
    int temp = *ptr1;  //*ptr1: ptr1가 가리키는 값
    *ptr1 = *ptr2;
    *ptr2 = temp;
}

int main() {
    int a = 10;
    int b = 20;

    std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;

    // swap 함수 호출해서 x와 y의 값 교환
    swap(&a, &b);

    std::cout << "After swap: a = " << a << ", b = " << b << std::endl;

    return 0;   
}

new를 굳이 사용하는 이유: 동적 메모리 할당

C++에서는 new 없이도 변수를 선언하고 사용할 수 있지만, new를 사용하는 이유는 메모리를 다루는 방식에 큰 차이가 있기 때문. new는 동적 메모리를 할당할 때 사용된다. 동적 메모리를 사용하면, 변수의 크기와 수명을 프로그래머가 마음대로 조절할 수 있다. 프로그램이 실행 중일 때 필요한 만큼 메모리를 만들고, 필요 없어지면 해제할 수 있다.

예시: 동적 메모리 할당

#include <iostream>
>
int main() {
    int* ptr = new int;  // 동적 메모리 할당 (정수형 변수 1개)
    *ptr = 20;           // 동적으로 할당된 메모리 공간에 값 저장
    std::cout << *ptr << std::endl;  // 값 출력
    delete ptr;          // 동적 메모리 해제
    return 0;
}

여기서 int* ptr = new int;는 실행 중에(런타임) 메모리를 직접 만들어서 사용할 수 있게 한다. 그리고 delete ptr;을 사용해서 수동으로 메모리를 해제해줘야 한다.

3. 정적 메모리와 동적 메모리의 차이