OnTheTop

• 데스크 테리어에 관심있는 사람들을 위해 생성형 AI 기반으로 퍼스널 데스크 특가 정보를 제공
  • 사용자의 데스크 셋업 이미지를 분석해 어울리는 아이템 이미지를 생성하고 클릭하면 바로 구매할 수 있는 쇼핑 링크를 제공

주요기능

• 사용자가 업로드한 책상 이미지를 AI가 분석하여 데스크 환경을 인식하고 어울리는 데스크 아이템을 추천
• 추천된 아이템을 Diffusion 모델을 기반으로 추천 데스크 셋업 이미지 생성
• 생성된 이미지를 기반으로 추천된 아이템을 구매할 수 있는 쇼핑 링크 제공
• 다양한 Style LoRA를 적용하여 MSPainting Style, Oil Painting Style, Cartoon Style 등 이미지 스타일 변경 기능 제공

AI Server Architecture

Folder

OTT_AI_Server
├── app
│   ├── core
│   │   ├── config.py
│   │   └── logging_config.py
│   ├── main.py
│   ├── routers
│   │   ├── __init__.py
│   │   ├── healthcheck.py
│   │   └── info.py
│   ├── services
│   │   ├── __init__.py
│   │   ├── backend_notify.py
│   │   ├── desk_classify.py
│   │   ├── gpt_api.py
│   │   ├── groundig_dino.py
│   │   ├── masking.py
│   │   ├── naverapi.py
│   │   ├── sam.py
│   │   └── sdxl_inpainting.py
│   ├── shutdown.py
│   ├── startup.py
│   └── utils
│       ├── clear_cache.py
│       ├── delete_image.py
│       ├── load_image.py
│       ├── mapping.py
│       ├── queue_manager.py
│       ├── s3.py
│       └── upscaling.py
├── README.md
├── requirements.txt
└── scripts
    ├── ai-server.service
    ├── start-ai.sh
    └── stop-ai.sh

Base Model

• Base Model로 Stable Diffusion XL 선정
• 다른 AI 모델들에 비해 적은 VRAM을 차지하며 생성 속도 또한 빠르기 때문에 가성비가 좋다.
• LoRA를 이용한 Fine Tuning이 가능하여 원하는 이미지 생성이 가능하다.
• 다른 AI 모델과의 비교는 Github Wiki 참조

Stable Diffusion XL

SDXL: Improving Latent Diffusion Models for High-Resolution Image Synthesis에 따르면 SDXL은 이전 Stable Diffusion 모델에 비해 세 배 더 큰 규모의 UNet 백본을 포함하며 2개의 텍스트 인코더를 사용해 더 나은 성능을 보여준다. 또한 후작업(refinement)모델이 도압되어 prompt 일관성과 고화질 유지를 모두 달성할 수 있다고 한다.



SDXL의 아키텍처를 보면 Base 부분은 UNet 기반의 확산 모델로 Prompt와 Noise를 입력받아 Unrefiend Latent를 생성한다. Unrefined Latent는 아직 세부 디테일이 부족한 상태로 Refiner Model를 통해 세부 묘사 및 시각적 품질을 개선하는 방식으로 작동된다. 마지막으로 VAE-Decoder를 통해 latent 공간을 실제 이미지 공간으로 복원하게 되며 여기서 128x128 latent를 1024x1024 해상도로 업스케일 된다.

UNet

UNet이라는 이름이 붙여진 이유는 구조가 ‘U’자 형태를 띄기 때문이다. 기본적으로는 오토인코더와 같은 인코더-디코더 기반 모델에 속한다.



UNet은 크게 Contracting Path(축소 경로)와 Expansive path(확장 경로)로 이루어진다. Contracting path는 일반적인 CNN과 유사하며 이미지의 정보 추출의 목적이다. Expanding path는 Up-convolution을 사용해 해상도를 증가시키며 정확학 경계 정보 유지와 세밀한 Feature 복원이 주 목적이다.

Stable Diffusion XL의 UNet Block의 구조는 아래와 같다.

conv_in
 
down_blocks:
    DownBlock2D:
        (ResnetBlock2D) x 2
        Downsample2D
    CrossAttnDownBlock2D:
        (ResnetBlock2D
        Transformer2DModel (BasicTransformerBlock x 2) ) x 2
        Downsample2D
    CrossAttnDownBlock2D:
        (ResnetBlock2D
        Transformer2DModel (BasicTransformerBlock x 10) ) x 2
 
mid_blocks:
        ResnetBlock2D
        Transformer2DModel
        ResnetBlock2D
 
up_blocks:
    CrossAttnUpBlock2D:
        (ResnetBlock2D
        Transformer2DModel (BasicTransformerBlock x 10) ) x 3
        Upsample2D
    CrossAttnUpBlock2D:
        (ResnetBlock2D
        Transformer2DModel (BasicTransformerBlock x 2) ) x 3
        Upsample2D
    UpBlock2D:
       (ResnetBlock2D) x 3
 
out

Stable Diffusion의 UNet 구조의 특징은 Self-Attention과 Cross-Attention의 개념이 사용된다.
두 개념은 일반적으로 Transformer 기반에서 사용되는 개념으로 Self-Attention은 자기 자신과의 관계에 주목하며, Cross-Attention은 두 입력 간의 관계에 주목하게 된다. Stable Diffusion에서는 Self-Attention은 이미지 latent 내부의 위치 간 관계를 파악해 자연스러운 구조, 질감을 형성하며 Cross-Attention은 텍스트 임베딩과의 관계를 통해 텍스트 조건에 맞는 이미지를 생성하게 된다.

LoRA

일반적으로 사전학습 된 LLM은 Full-Fine tuning 방식은 모든 파라미터 업데이트로 인해 계산 비용, GPU 메모리, 저장 공간 부담이 크다. GPT-3가 175B 이므로 Full-Fine tuning을 한다면 약 1750억개의 파라미터를 저장해야한다.

LoRA는 기존 모델의 가중치를 학습 중 직접 수정하지 않고 보정행렬을 삽입하여 fine tuning하는 방법이다.
사전학습된 모델 가중치 $W$는 동결하고 작은 저차원 행렬 $A (r \times k)$와 $B (d \times r)$를 추가학습하여 \(\Delta W = BA, W' = W + \Delta W\) 형태로 표현할 수 있다.

Stable Diffusion에서는 UNet내부 Attention에 적용되며 선형 projection 레이어에만 적용된다.
\(W_qx \Rightarrow \left ( W_q + \frac{\alpha}{\gamma}B_q A_q \right )x\) 위의 수식과 같은 방식으로 $Q$, $K$, $V$, $O$(Out projection)에 $\Delta W$가 붙게 된다.
기존의 Weight의 구조가 $Q = x \cdot W_q$라면 .load_lora_weight() 메서드 적용후에는 $Q = x \cdot W_q + (x \cdot A_q)B_q$의 구조가 된다.

LoRA 학습

• LoRA의 경우 kohya_ss를 사용하여 Custom 학습 하였다.
• 학습 이미지의 경우 GPT-4o 이미지 생성 기능을 이용해 깔끔한 Desksetup 기반 이미지 121장(1024x1024)을 추출하여 학습에 사용하였다.
• 이미지 예시

Desk Classify

• Desk Classify 목적 설명
• CNN 학습 및 경량화 과정
• Desk Classify가 가져온 이점

Grounding DINO

• Grounding DINO 목적 설명 YOLO와의 비교
• Grounding DINO의 Output 값 등 설명

SAM2.1

• SAM2 논문 소개하며 SAM2 기능 설명
• Segmentation 설명 및 단점 등 설명
• Mask Image 처리 과정 설명 등

Major Update

• 주요 업데이트 설명 및 트러블 슈팅 과정을 설명

Test Version

• CNN 도입 과정 설명

V1

• LoRA학습 및 img2txt -> txt2img pipeline 설명

V2

• Inpainting 도입과정 설명 및 Grounding DINO, SAM2.1을 이용한 Auto Masking Process 설명
• Style LoRA 적용

V3

• Redis를 응용한 Multi-GPU

  최근 다양한 CNN(Convolutional Neural Network) 기반의 이미지 분류 모델들이 제안되며 이미지 인식 분야에서 뛰어난 성능을 보이고 있다. 하지만 이러한 모델들은 구조의 복잡성이나 파라미터 수에 따라 연산 비용과 메모리 사용량에 큰 차이를 보이며, 특히 데이터셋의 특성에 따라 성능 및 효율성이 달라질 수 있다.
  실제 응용 환경에서는 모델의 경량화 또한 중요한 과제로 떠오르고 있다. 모바일 기기, 임베디드 시스템, 자동화 기계 등에서는 모델의 정확도뿐만 아니라 처리 속도와 자원 효율성이 중요한 요소로 작용하기 때문이다.
  따라서 본 프로젝트에서는 ‘Rice Image Dataset’을 활용하여 여러 CNN 기반 모델들이 해당 데이터셋에서 어떤 성능을 보이는지 비교하고 모델별 특징 및 효율성을 분석하고자 한다. 특히, 이미지 분류 과정에서 생성되는 Feature map을 시각화함으로써 각 모델이 어떤 방식으로 이미지를 인식하고 구분하는지 직관적으로 이해하고자 하였다.
  이를 통해 더 이상 특징을 제대로 추출하지 못 하는 Layer를 일부 제거하거나 Filter의 수를 줄임 성능저하 없이 예측 효율성을 개선할 수 있는 가능성도 살펴보고자한다. 이러한 분석을 통해 단순 정확도 비교를 넘어서 실제 응용에 적합한 효율적인 모델을 선정하기 위한 방법을 살펴보고자 한다.

(1) 모델 경량화

  모델 경량화가 필요한 이유는 다양하지만 비용적 문제가 크다. 모델이 크고 계산량이 많아질수록 전력 소비량이 늘어나고 열 발생량도 높아진다. 심지어 최근에는 스마트폰, IoT 기기 등에도 탑재하고자 노력 중이다. 따라서 모델이 가볍고 성능은 뒤떨어지지 않는 것이 중요하다.
  모델 경량화의 Solution은 Pruning, Quantization, Knowledg Distillation 등 다양하게 존재한다. 하지만 본 프로젝트에서는 Filter를 통과한 Featrue Map을 시각화하여 불필요한 Filter를 삭제해봄으로써 모델 경량화를 하고자 한다.
  또한 모델을 경량화하다보면 일반화 성능이 좋아지는 부수적인 이득을 볼 수 있다. 따라서 모델을 경량화 해보면서 각 모델의 일반화 성능을 살펴볼 것이다.

(2) Feature Map

  CNN은 Convolution Layer를 통해 이미지의 주요 특징을 추출하며 이때, 각 필터를 통과한 결과가 Feature Map으로 생성된다. 이후 이 Feature Map은 Pooling Layer를 거쳐 중요한 특징을 강조하고 불필요한 정보를 축소하게 된다. 이러한 과정을 반복한 후에는, 최종적으로 Fully Connected Layer에 전달되어 우리가 흔히 알고 있는 인공신경망(ANN) 구조처럼 분류 작업을 수행하게 된다.

  예를 들어 고양이 사진을 CNN구조인 VGG16에 통과시키면 아래와 같은 Feature Map을 얻을 수 있다.

이미지 출처

LifeofPy, CNN의 정의, 이미지의 feature map 기능과 kernel(filter)의 개념

   하지만 본 프로젝트에서 사용하는 ‘Rice Image Dataset’의 경우 CNN의 층이 깊어질수록 불필요한 특징이 잡힐 수 있다. 해당 Dataset을 VGG16에 통과시킨 후의 Feature Map의 차이를 보면 아래와 같다.

  위의 Feature Map은 VGG16의 첫 번째 Convolution Layer를 통과한 이미지이다.


  해당 Feature Map은 VGG16의 마지막 Convolution Layer를 통과한 이미지이다. 모든 Filter에 대한 Featrue Map을 출력한 것은 아니지만 대부분의 Filter가 특징을 추출하지 못한 채 모두 검정색임을 알 수 있다. 해당 현상은 Fully Connected Layer에서 문제가 발생할 수 있다.

(3) Feed Forward 관점

  Convolution → ReLU → MaxPooling 형태의 CNN 층을 수식으로 표현하면 아래와 같다.
$X \in \mathbb{R}^{C_{in}\times H \times W}$
$W \in \mathbb{R}^{C_{out}\times C_{in} \times K’ \times K}$
$b_i \in \mathbb{R}$
  출력 채널 $i$, 위치 $(m, n)$에서의 convolution 출력은 아래의 식과 같다.

  ReLU는 음수를 0으로 만들고 양수는 그대로 유지하므로 아래의 식과 같다.

   $2 \times 2$ 커널에서의 Max Pooling은 아래의 식과 같다.

  Feature Map의 모든 값이 0일 경우, 다음과 같이 출력된다.

  이처럼 Feature Map이 0으로 채워져 있을 경우, ReLU 및 Pooling을 통과한 이후에도 출력값은 여전히 0이다.
  Fully Connected Layer는 $y = Wx + b$로 표현되므로 모든 입력값 $x = 0$ 이라면, 출력 $y$는 오직 bias$(b)$에만 의존하게 된다.이 상황에서는 실제 이미지로부터 추출한 특징이 전혀 반영되지 않으며 모델은 유의미한 학습이 불가능하게 된다.
  결국 이는 모델이 정답을 무작위로 선택하는 것과 유사한 상태로 이어질 수 있다.

(4) Backpropagation 관점

  Backpropagation의 관점에서 보면, Fully Connected Layer(FCL)의 입력값이 모두 $x=0$ 인 경우, Convolution Layer의 필터는 업데이트되지 않게 된다.

  FCL을 $y = \phi(Wx+b)$로 표현할 수 있을 때, $x = 0$이면 $y = \phi(b)$가 된다. 해당 상황에서 FCL의 가중치 $W$에 대한 손실함수의 기울기를 구하면 다음과 같다.
\(\frac{\partial L}{\partial W} = \frac{\partial L}{\partial y} \cdot \phi '(b) \cdot x^{T} = 0\)
따라서 FCL의 가중치는 학습되지 않으며 오직 bias의 영향만 받게 된다.
  입력 $X$에 대하여 Convolution → ReLU → Pooling 순으로 연산이 이루어진다고 할 때, Convolution Layer의 weight $W_{conv}$에 대한 기울기는 다음과 같이 chain rule로 표현된다.
\(\frac{\partial L}{\partial W_{conv}} = \frac{\partial L}{\partial A} \cdot \frac{\partial A}{\partial Z} \cdot \frac{\partial Z}{\partial W_{conv}}\)
   앞서 구한 바와 같이 $\frac{\partial L}{\partial W} = 0$이므로 $\frac{\partial Z}{\partial W_{conv}} = 0$ 이다. 이로인해 Convolution Layer의 필터 역시 학습되지 않게 된다. 결국 bias만 업데이트 되며 의미 없는 학습이 반복될 뿐이다.

  이론적으로도 마지막 Feature Map의 모든 값이 0인 경우에는 학습이 이루어지지 않으며 이는 실험적으로도 관찰 가능하다. 본 프로젝트에서는 Feature Map을 grayscale로 출력하였기 때문에 모든 채널(R, G, B)이 동시에 0인지를 정확히 시각적으로 판단하기는 어렵지만, GoogLeNet을 이용해 이를 간접적으로 확인할 수 있었다.
  GoogLeNet의 대표적인 특징은 1×1 Convolution 연산이다. 이 연산은 Feature Map의 공간적 크기를 유지하면서 채널 수를 줄이는 역할을 한다. 즉, RGB 각각의 특성이 하나의 채널로 압축되는 구조로, 학습이 충분히 진행되지 않은 경우 Feature Map 전체가 0으로 수렴할 가능성도 상대적으로 높아진다.
  또한 GoogLeNet은 총 27개의 Layer로 구성된 깊은 구조이기 때문에, 학습이 불안정하거나 정보가 사라질 경우 Feature Map이 0으로 소멸될 위험성도 다른 모델보다 더 클 수 있다.

  아래의 내용은 실제 weight를 초기화 해보면서 학습을 시도한 결과 얻은 GoogLeNet 학습 결과이다. 학습 로그에서 확인할 수 있듯이 학습이 진행되는 동안 ‘val_accuracy’는 0.1956, ‘val_loss’는 1.6096에서 변하지 않고 반복되었다. 이는 Backpropagation이 정상적으로 이루어지지 않고 bias만 업데이트 되는 현상이 발생했을 가능성이 크다.

학습 불가 Colab Link, 프로젝트 Colab Link 두 링크를 통해 비교해보면 코드는 같은 걸 알 수 있다.
  Cross-Entropy Loss는 아래와 같이 정의된다.
\(L = -\sum _ {i=1} ^{C} y_{i} \cdot \log(\hat{y}_{i})\)
  모델이 모든 클래스를 동일한 확률로 예측한다면 각 클래스의 예측 확률은 $\hat{y}_{i} = \frac{1}{C}$이다. 그리고 Cross-Entropy는 정답 클래스에만 적용되므로 $L = \log(C)$가 된다. 즉, 무작위 추측 시의 Cross-Entropy Loss는 $\log(C)$가 된다.
  따라서 Class수가 5일 때, 무작위 추측 시 Cross-Entropy Loss는 $\log(5) \approx \ln(5) \approx 1.609$이다. 따라서 ‘val_loss’가 1.609에서 멈춰 있다는건 모델이 학습을 하지 못하고 무작위로 예측하고 있다는 강력한 증거이다.

2. 데이터셋 설명

  본 프로젝트에서 사용한 데이터셋은 Kaggle의 ‘Rice Image Dataset’으로 Murat Koklu에 의해 제공되었다.
  해당 데이터셋은 Arborio, Basmati, Ipsala, Jasmine, Karacadag로 총 5가지 class로 구분되어 있으며 각 데이터는 15,000개로 총 75,000개의 .jpg 이미지로 구성되어있다.
   각 이미지는 250x250 픽셀 크기를 가지며 검은 배경 위에 단일 쌀알이 위치한 형태로 구성되어 있다. 이미지들은 쌀알 이외의 잡음은 없고 배경과 객체가 명확히 구분되도록 전처리 되어있어 이미지 분류 모델 학습에 적합한 데이터이다.

(1) Data Load

• Kaggle을 이용한 Data Load

!kaggle datasets download -d nuratkokludataset/rice-image-dataset
!unzip rice-image-dataset.zip -d rice_dataset

• Dataset 확인
  해당 데이터는 folder로 class화 해놓았기 때문에 folder별로 class index를 붙여주어야 한다.

dataset_path = '.../rice_dataset/Rice_Image_Dataset'

class_folders = [f.name for f in os.scandir(dataset_path) if f.is_dir()]
num_classes = len(class_folders)

print("Class Folders:", class_folders)
print("Number of Classes:", num_classes)

Class Folders: ['Ipsala', 'Arborio', 'Karacadag', 'Jasmine', 'Basmati']
Number of Classes: 5

path = pathlib.Path(dataset_path)

arborio = list(path.glob('Arborio/*.jpg'))
basmati = list(path.glob('Basmati/*.jpg'))
ipsala = list(path.glob('Ipsala/*.jpg'))
jasmine = list(path.glob('Jasmine/*.jpg'))
karacadag = list(path.glob('Karacadag/*.jpg'))

print(f'Arborio: {len(arborio)}')
print(f'Basmati: {len(basmati)}')
print(f'Ipsala: {len(ipsala)}')
print(f'Jasmine: {len(jasmine)}')
print(f'Karacadag: {len(karacadag)}')

rborio: 15000
Basmati: 15000
Ipsala: 15000
Jasmine: 15000
Karacadag: 15000

basmati_img = img.imread(basmati[0])
arborio_img = img.imread(arborio[0])
ipsala_img = img.imread(ipsala[0])
jasmine_img = img.imread(jasmine[0])
karacadag_img = img.imread(karacadag[0])

fig,ax = plt.subplots(ncols=5, figsize=(20,5))
fig.suptitle ('Rice Category', fontsize=40)

ax[0].set_title("arborio")
ax[1].set_title("basmati")
ax[2].set_title("ipsala")
ax[3].set_title("jasmine")
ax[4].set_title("karacadag")
ax[0].imshow(arborio_img)
ax[1].imshow(basmati_img)
ax[2].imshow(ipsala_img)
ax[3].imshow(jasmine_img)
ax[4].imshow(karacadag_img)

plt.show()

3. 모델 구성

(1) CNN

• 일반적인 CNN으로 Convolution → ReLu → MaxPooling 으로 3개 층으로 쌓아보았으며 필터의 개수는 32 → 64 → 128 개를 사용하여 Feature Map을 시각화 하였다.

  def cnn(input_shape, num_classes):
    inputs = tf.keras.Input(shape=input_shape)
    x = tf.keras.layers.Conv2D(32, (3,3), activation='relu', padding='same')(inputs)
    x = tf.keras.layers.MaxPooling2D((2,2))(x)
    x = tf.keras.layers.Conv2D(64, (3,3), activation='relu', padding='same')(x)
    x = tf.keras.layers.MaxPooling2D((2,2))(x)
    x = tf.keras.layers.Conv2D(128, (3,3), activation='relu', padding='same')(x)
    x = tf.keras.layers.MaxPooling2D((2,2))(x)
    x = tf.keras.layers.Flatten()(x)
    x = tf.keras.layers.Dense(128, activation='relu')(x)
    outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
    model = tf.keras.Model(inputs, outputs)
    return model
  
  cnn = cnn(input_shape = img_size + (3, ), num_classes=5)
  cnn.compile(optimizer='adam',
                    loss='categorical_crossentropy',
                    metrics=['accuracy'])
  cnn.summary()
  

Model Summary

Total params: 12,939,077 (49.36 MB)
Trainable params: 12,939,077 (49.36 MB)
Non-trainable params: 0 (0.00 B)

Model Evaluation

  Restoring model weights from the end of the best epoch: 9.

Best score인 9번 째 epoch의 evaluation은 아래와 같다.
Train Accuracy: 0.9986
Train Loss: 0.0040
Validation Accuracy: 0.9963
Validation Loss: 0.0132

Feature Map 시각화

  부분적으로 Filter를 거친 후 Feature Map이 검은색인 경우가 많다. 이는 계산에 큰 영향을 미치지 않을 것이라 판단되어 Filter의 개수를 줄여 개선을 경량화를 해보고자 한다.

(2) CNN 경량화

• 일반적인 CNN으로 Convolution → ReLu → MaxPooling 으로 2개 층으로 쌓아보았으며 필터의 갯수는 8 → 16 개를 사용하여 이전과 다르게 strides 추가하여 Feature Map의 크기를 줄여보았다.

  def cnn_light(input_shape, num_classes):
    inputs = tf.keras.Input(shape=input_shape)
    x = tf.keras.layers.Conv2D(8, (3,3), activation='relu', strides = (2,2), padding='same')(inputs)
    x = tf.keras.layers.MaxPooling2D((2,2), strides = (2,2))(x)
    x = tf.keras.layers.Conv2D(16, (3,3), activation='relu', strides = (2,2), padding='same')(x)
    x = tf.keras.layers.MaxPooling2D((2,2), strides = (2,2))(x)
    x = tf.keras.layers.Flatten()(x)
    x = tf.keras.layers.Dense(16, activation='relu')(x)
    outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
    model = tf.keras.Model(inputs, outputs)
    return model
  

Model Summary

Total params: 51,669 (201.83 KB)
Trainable params: 51,669 (201.83 KB)
Non-trainable params: 0 (0.00 B)

Model Evaluation

  Restoring model weights from the end of the best epoch: 19.

Best score인 19번 째 epoch의 evaluation은 아래와 같다.
Train Accuracy: 0.9986
Train Loss: 0.0044
Validation Accuracy: 0.9970
Validation Loss: 0.0108

Feature Map 시각화

해당 모델은 3개의 층으로 쌓은 CNN에 비해 유효한 특징만 추출한 것을 확인할 수 있다.

모델 비교

Parameter 수는 각 12,939,077와 51,669로 99.60(%) 경량화하였으며 Accuracy와 Loss를 보았을 때, 성능차이는 거의 없으며 오히려 경량화 모델이 소폭 높은 것을 확인할 수 있다.

(3) GoogLeNet

• GoogLeNet의 구조는 아래 이미지와 같다.
  
  GoogLeNet은 총 27개의 Layer로 구성되어 있고 Stem Network는 신경망의 초기 부분으로 일반적인 CNN의 은닉 구조를 가진다. Inception Module은 GoogLeNet의 핵심적인 구조로 Layer를 하나의 Sub-Network구조로 구성하여 연산량을 줄이는 구조이다.
  사전 학습된 Weight 없이 직접 해당 구조를 쌓아보았다.
  

  class InceptionModule(layers.Layer):
    def __init__(self, f1, f3_reduce, f3, f5_reduce, f5, pool_proj, **kwargs):
        super(InceptionModule, self).__init__(**kwargs)
        # 1x1 conv branch
        self.branch1 = layers.Conv2D(f1, (1,1), padding='same', activation='relu')
          
        # 1x1 -> 3x3 branch
        self.branch2 = models.Sequential([
            layers.Conv2D(f3_reduce, (1,1), padding='same', activation='relu'),
            layers.Conv2D(f3, (3,3), padding='same', activation='relu')
        ])
          
        # 1x1 -> 5x5 branch
        self.branch3 = models.Sequential([
            layers.Conv2D(f5_reduce, (1,1), padding='same', activation='relu'),
            layers.Conv2D(f5, (5,5), padding='same', activation='relu')
        ])
          
        # 3x3 max pooling -> 1x1 conv branch
        self.branch4 = models.Sequential([
            layers.MaxPooling2D((3,3), strides=(1,1), padding='same'),
            layers.Conv2D(pool_proj, (1,1), padding='same', activation='relu')
        ])
      
    def call(self, x):
        branch1 = self.branch1(x)
        branch2 = self.branch2(x)
        branch3 = self.branch3(x)
        branch4 = self.branch4(x)
        return tf.concat([branch1, branch2, branch3, branch4], axis=-1)
  

  def create_googlenet(input_shape, num_classes):
    inputs = layers.Input(shape=input_shape)
      
    # Stem network
    x = layers.Conv2D(64, (7,7), strides=(2,2), padding='same', activation='relu')(inputs)
    x = layers.MaxPooling2D((3,3), strides=(2,2), padding='same')(x)
    x = layers.Conv2D(64, (1,1), padding='same', activation='relu')(x)
    x = layers.Conv2D(192, (3,3), padding='same', activation='relu')(x)
    x = layers.MaxPooling2D((3,3), strides=(2,2), padding='same')(x)
      
    # Inception modules
    x = InceptionModule(64, 96, 128, 16, 32, 32)(x)
    x = InceptionModule(128, 128, 192, 32, 96, 64)(x)
    x = layers.MaxPooling2D((3,3), strides=(2,2), padding='same')(x)
      
    x = InceptionModule(192, 96, 208, 16, 48, 64)(x)
    x = InceptionModule(160, 112, 224, 24, 64, 64)(x)
    x = InceptionModule(128, 128, 256, 24, 64, 64)(x)
    x = InceptionModule(112, 144, 288, 32, 64, 64)(x)
    x = InceptionModule(256, 160, 320, 32, 128, 128)(x)
    x = layers.MaxPooling2D((3,3), strides=(2,2), padding='same')(x)
      
    x = InceptionModule(256, 160, 320, 32, 128, 128)(x)
    x = InceptionModule(384, 192, 384, 48, 128, 128)(x)
      
    # 최종 분류기
    x = layers.GlobalAveragePooling2D()(x)
    x = layers.Dropout(0.4)(x)
    outputs = layers.Dense(num_classes, activation='softmax')(x)
      
    model = models.Model(inputs, outputs)
    return model
  
  googlenet = create_googlenet(input_shape=img_size + (3,), num_classes=5)
  googlenet.compile(optimizer='adam',
                    loss='categorical_crossentropy',
                    metrics=['accuracy'])
  googlenet.summary()
  

Model Summary

Total params: 5,978,677 (22.81 MB)
Trainable params: 5,978,677 (22.81 MB)
Non-trainable params: 0 (0.00 B)

Model Evaluation

  Restoring model weights from the end of the best epoch: 24.

Best score인 24번 째 epoch의 evaluation은 아래와 같다.
Train Accuracy: 0.9988
Train Loss: 0.0039
Validation Accruacy: 0.9975
Validation Loss: 0.0111

Feature Map 시각화

Feature Map은 Stem Network만 시각화해보았다.

(4) GoogLeNet 경량화

• 해당 모델은 Stem Network의 Filter의 개수를 줄이고 각 Inception Module의 Filter 개수를 줄여주었다. 또한 2단계의 Inception Module 하나를 삭제하므로써 연산량을 줄였다. Inception Module의 내부 구조는 GoogLeNet의 특징이므로 건드리지 않았다.

  # Inception Module은 GoogLeNet과 같으므로 생략
  
  def create_googlenet_light(input_shape, num_classes):
      inputs = layers.Input(shape=input_shape)
  
      # Stem network
      x = layers.Conv2D(16, (7,7), strides=(2,2), padding='same', activation='relu')(inputs)
      x = layers.MaxPooling2D((3,3), strides=(2,2), padding='same')(x)
      x = layers.Conv2D(16, (1,1), padding='same', activation='relu')(x)
      x = layers.Conv2D(64, (3,3), padding='same', activation='relu')(x)
      x = layers.MaxPooling2D((3,3), strides=(2,2), padding='same')(x)
  
      # Inception modules
      x = InceptionModule(16, 16, 24, 4, 8, 8)(x)
      x = InceptionModule(24, 24, 32, 4, 8, 8)(x)
      x = layers.MaxPooling2D((3,3), strides=(2,2), padding='same')(x)
  
      x = InceptionModule(32, 32, 48, 8, 16, 16)(x)
      x = InceptionModule(48, 48, 64, 8, 16, 16)(x)
      x = InceptionModule(64, 64, 96, 12, 24, 24)(x)
      x = InceptionModule(96, 64, 96, 12, 24, 24)(x)
      x = layers.MaxPooling2D((3,3), strides=(2,2), padding='same')(x)
  
      x = InceptionModule(96, 64, 96, 12, 24, 24)(x)
      x = InceptionModule(96, 96, 128, 16, 32, 32)(x)
  
      # 최종 분류기
      x = layers.GlobalAveragePooling2D()(x)
      x = layers.Dropout(0.4)(x)
      outputs = layers.Dense(num_classes, activation='softmax')(x)
  
      model = models.Model(inputs, outputs)
      return model
  
  googlenet_light = create_googlenet_light(input_shape=img_size + (3,), num_classes=5)
  googlenet_light.compile(optimizer='adam',
                    loss='categorical_crossentropy',
                    metrics=['accuracy'])
  googlenet_light.summary()
  

Model Summary

Total params: 580,905 (2.22 MB)
Trainable params: 580,905 (2.22 MB)
Non-trainable params: 0 (0.00 B)

Model Evaluation

  Restoring model weights from the end of the best epoch: 16.

Best score인 16번 째 epoch의 evaluation은 아래와 같다.
Train Accuracy: 0.9983
Train Loss: 0.0071
Validation Accuracy: 0.9981
Validation Loss: 0.0070

Feature Map 시각화

Feature Map은 위와 마찬가지로 Stem Network만 시각화해보았다.

모델 비교

Parameter 수는 각 5,978,677와 580,905로 90.28(%) 경량화하였으며 Accuracy와 Loss를 보았을 때, 성능차이는 거의 없으며 오히려 경량화 모델이 소폭 높은 것을 확인할 수 있다.

(5) VGG16

• VGG16은 구조가 매우 간단하며 아래와 같은 구조를 가진다.
  
  VGG16은 모든 Convolution Layer에 3x3 필터를 적용하는 것이 큰 특징이다. 구조가 간단하고 이해가 쉽고 변형을 시켜가면서 테스트 하기 용이해 자주 사용되는 모델이다. 해당 모델은 Feature Map 크기는 동일하지만 학습해야할 파라미터 수를 줄였다는 특징이 있다.
  해당 모델은 ‘Rice Image Project 예시‘를 참고하여 Imagenet으로 사전학습 된 모델에서 미세조정 하였다. 또한 이미지 증강은 사용하지 않았고 ‘Rice Image Dataset’을 그대로 사용하였다.
  

  input_tensor = Input(shape=img_size + (3,))
  
  # VGG16 base model
  base_model = VGG16(include_top=False,
                    weights='imagenet',
                    input_tensor=input_tensor)
  
  # 필요한 레이어만 학습되도록 설정
  for layer in base_model.layers[:-4]:
      layer.trainable = False
  
  # 커스텀 분류기 추가
  x = base_model.output
  x = GlobalAveragePooling2D()(x)
  x = Dense(512, activation='relu')(x)
  x = Dropout(0.3)(x)
  output_tensor = Dense(5, activation='softmax')(x)
  
  vgg16 = Model(inputs=input_tensor, outputs=output_tensor)
  vgg16.compile(optimizer='adam',
                loss='categorical_crossentropy',
                metrics=['accuracy'])
  vgg16.summary()
  

Model Summary

Total params: 14,979,909 (57.14 MB)
Trainable params: 7,344,645 (28.02 MB)
Non-trainable params: 7,635,264 (29.13 MB)

Model Evaluation

  Restoring model weights from the end of the best epoch: 11.

Best score인 11번 째 epoch의 evaluation은 아래와 같다.
Train Accuracy: 0.9994
Train Loss: 0.0024
Validation Accuracy: 0.9979
Validation Loss: 0.0099

Feature Map 시각화

(6) VGG16 경량화

• 사전학습 되어있는 Filter를 그대로 사용하고 block_5는 특징 추출이 되지 않은 형태로 보이므로 삭제하여 경량화였다.

  x = vgg16.get_layer('block4_pool').output
  
  # 분류기 추가
  x = GlobalAveragePooling2D()(x)
  x = Dense(512, activation='relu')(x)
  x = Dropout(0.3)(x)
  output_tensor = Dense(5, activation='softmax')(x)
  
  # 전체 모델 정의
  vgg_light = Model(inputs=input_tensor, outputs=output_tensor)
  
  # 필요한 레이어만 학습되도록 설정
  for layer in vgg16.layers:
      layer.trainable = False
  
  vgg_light.compile(optimizer='adam',
                    loss='categorical_crossentropy',
                    metrics=['accuracy'])
  vgg_light.summary()
  

Model Summary

Total params: 7,900,485 (30.14 MB)
Trainable params: 265,221 (1.01 MB)
Non-trainable params: 7,635,264 (29.13 MB)

Model Evaluation

  Restoring model weights from the end of the best epoch: 28.

Best score인 28번 째 epoch의 evaluation은 아래와 같다.
Train Accuracy: 0.9982
Train Loss: 0.0061
Validation Accuracy: 0.9977
Validation Loss: 0.0077

Feature Map 시각화

사전 학습된 모델 그대로 가져왔으므로 Filter를 통과한 Feature Map은 동일하다.

(7) VGG Custom

• VGG16 모델과 경량화 모델은 모두 Imagenet으로 사전학습된 모델이다. 해당 모델은 VGG16의 구조를 따라가되 직접 학습한 모델이며 총 3개의 block으로 이루어져있다.

  def vgg_custom(input_shape=(224, 224, 3), num_classes=5):
      inputs = layers.Input(shape=input_shape)
  
      # Block 1 - 16 filters
      x = layers.Conv2D(16, (3, 3), activation='relu', padding='same')(inputs)
      x = layers.Conv2D(16, (3, 3), activation='relu', padding='same')(x)
      x = layers.MaxPooling2D((2, 2))(x)
  
      # Block 2 - 32 filters
      x = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(x)
      x = layers.Conv2D(32, (3, 3), activation='relu', padding='same')(x)
      x = layers.MaxPooling2D((2, 2))(x)
  
      # Block 3 - 64 filters
      x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
      x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
      x = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
      x = layers.MaxPooling2D((2, 2))(x)
  
      x = layers.GlobalAveragePooling2D()(x)
      x = layers.Dense(512, activation='relu')(x)
      x = layers.Dropout(0.5)(x)
      outputs = layers.Dense(num_classes, activation='softmax')(x)
  
      model = models.Model(inputs, outputs)
      return model
      
  vgg_custom = vgg_custom(input_shape=img_size + (3,), num_classes=5)
  vgg_custom.compile(optimizer='adam',
                    loss='categorical_crossentropy',
                    metrics=['accuracy'])
  vgg_custom.summary()
  

Model Summary

Total params: 144,853 (565.83 KB)
Trainable params: 144,853 (565.83 KB)
Non-trainable params: 0 (0.00 B)

Model Evaluation

  Restoring model weights from the end of the best epoch: 41.

Best score인 41번 째 epoch의 evaluation은 아래와 같다.
Train Accuracy: 0.9986
Train Loss: 0.0051
Validation Accuracy: 0.9988
Validation Loss: 0.0042

Feature Map 시각화

각 블럭의 1층 Feature Map만 시각화하였다.

모델 비교

Parameter 수는 각 VGG16 모델 대비 99.03(%) 경량화하였으며 VGG 경량화 모델 대비 98.16(%)경량화 되었다. Accuracy와 Loss를 보았을 때, 성능차이는 VGG16 Custom 모델이 제일 높은 성능을 보여준다.

4. 모델별 일반화 성능비교

  각 학습한 모델들을 .h5형태로 저장하였으며 일반화 성능과 추론 속도를 보기 위해 기존의 데이터를 가공하여 사용해보았다.

raw_test_ds = tf.keras.preprocessing.image_dataset_from_directory(
    test_fpath,
    image_size=img_size,
    batch_size=batch_size,
    shuffle=False,
    label_mode='categorical'
)

class_names = raw_test_ds.class_names

data_augmentation = tf.keras.Sequential([
    layers.RandomFlip("horizontal"), # 수평 뒤집기
    layers.RandomRotation(0.1), # ±10% 회전
    layers.RandomZoom(0.1), # ±10% 확대/축소
    layers.RandomTranslation(0.1, 0.1), # ±10% 가로/세로 이동
    layers.RandomContrast(0.1) # 명암 변화
])

normalization_layer = tf.keras.layers.Rescaling(1./255)
test_ds = raw_test_ds.map(lambda x, y: (normalization_layer(data_augmentation(x)), y))

AUTOTUNE = tf.data.AUTOTUNE
test_ds = test_ds.prefetch(buffer_size=AUTOTUNE)

  추론 속도는 정확한 값으로 측정하기 위해서 FLOPs로 대체하였다. FLOPs란 FLoating point Operations의 약자로 부동소수점 연산을 의미하며 주로 모델의 계산 복잡성을 측정하는데 사용된다. Device Performance는 대개 FLOPS(FLoating point Operations Per Second)로 측정하고 있으며 추론 시간은 Device의 성능이 높을수록 계산해야하는 FLOPs가 낮을수록 추론시간은 짧아진다. CNN 계열 모델의 이론적 추론시간은 아래와 같다.
\(Inference\,Time = \frac{\sum_{l=1}^{L}FLOPs_l}{Device\,Performance\,(FLOPs/sec)}\)
  일반적으로 Convolution Lyaer의 FLOPs의 계산은 아래와 같이 계산된다.

$C_{in}$: 입력 채널 수
$K$: 커널크기
$H_{out}, W_{out}$: Feature Map의 Height, Width
$C_{out}$: 출력 채널 수

\(FLOPs_{conv} = 2 \times C_{in} \times K^2 \times H_{out} \times W_{out} \times C_{out}\)

  여기서 Layer를 제거하거나 Filter의 개수를 줄이게 되면 이후 Layer에서의 $C_{in}$값 또한 감소한다. 따라서 연산량이 전반적으로 줄어들게 되며 상당한 계산량 절감 효과를 기대할 수 있다.

def get_flops(model, batch_size=1):
    try:
        concrete = tf.function(lambda x: model(x))
        concrete_func = concrete.get_concrete_function(
            tf.TensorSpec([batch_size, 224, 224, 3], tf.float32))

        frozen_func = convert_to_constants.convert_variables_to_constants_v2(concrete_func)
        graph_def = frozen_func.graph.as_graph_def()

        with tf.Graph().as_default() as graph:
            tf.graph_util.import_graph_def(graph_def, name='')
            run_meta = tf.compat.v1.RunMetadata()
            opts = tf.compat.v1.profiler.ProfileOptionBuilder.float_operation()
            flops = tf.compat.v1.profiler.profile(graph=graph, run_meta=run_meta, cmd='op', options=opts)
            return flops.total_float_ops
    except Exception as e:
        print(f"FLOPs 계산 실패: {e}")
        return None

(1) CNN

• 총 필터 수: 224개

• 이미지 1장 당 FLOPs : 1,042,859,422 (약 1.04 GFLOPs)
  이미지 7,500장 : 약 7.82 TFLOPs

• Test Accuracy : 0.7092

• Confusion Matrix
  
  

  Class	Precision	Recall	F1-Score	Support
  Arborio	0.91	0.55	0.68	1500
  Basmati	0.68	0.90	0.77	1500
  Ipsala	0.88	0.96	0.92	1500
  Jasmine	0.48	0.60	0.53	1500
  Karacadag	0.76	0.53	0.62	1500
  Accuracy			0.71	7500
  Macro Avg	0.74	0.71	0.71	7500
  Weighted Avg	0.74	0.71	0.71	7500

(2) CNN 경량화

• 총 필터 수: 24개

• 이미지 1장 당 FLOPs : 7,551,694 (약 7.55 MFLOPs)
  이미지 7,500장 : 약 56.64 GFLOPs

• Test Accuracy : 0.7456

• Confusion Matrix
  
  

  Class	Precision	Recall	F1-Score	Support
  Arborio	0.85	0.60	0.70	1500
  Basmati	0.67	0.96	0.79	1500
  Ipsala	0.97	0.94	0.95	1500
  Jasmine	0.54	0.77	0.63	1500
  Karacadag	1.00	0.47	0.64	1500
  Accuracy			0.75	7500
  Macro Avg	0.80	0.75	0.74	7500
  Weighted Avg	0.80	0.75	0.74	7500

(3) GoogLeNet

• 총 필터 수: 5,808개

• 이미지 1장 당 FLOPs : 3,179,339,598 (약 3.18 GFLOPs)
  이미지 7,500장 : 약 23.85 TFLOPs

• Test Accuracy : 0.8675

• Confusion Matrix
  
  

  Class	Precision	Recall	F1-Score	Support
  Arborio	0.93	0.69	0.79	1500
  Basmati	0.92	0.98	0.95	1500
  Ipsala	0.88	0.99	0.93	1500
  Jasmine	0.71	0.91	0.80	1500
  Karacadag	0.99	0.76	0.86	1500
  Accuracy			0.87	7500
  Macro Avg	0.89	0.87	0.87	7500
  Weighted Avg	0.89	0.87	0.87	7500

(4) GoogLeNet 경량화

• 총 필터 수: 1,456개

• 이미지 1장 당 FLOPs : 280,058,490 (약 0.28 GFLOPs)
  이미지 7,500장 : 약 2.10 TFLOPs

• Test Accuracy : 0.9319

• Confusion Matrix
  
  

  Class	Precision	Recall	F1-Score	Support
  Arborio	0.91	0.87	0.89	1500
  Basmati	0.97	0.99	0.98	1500
  Ipsala	0.98	0.99	0.98	1500
  Jasmine	0.83	0.98	0.90	1500
  Karacadag	1.00	0.83	0.91	1500
  Accuracy			0.93	7500
  Macro Avg	0.94	0.93	0.93	7500
  Weighted Avg	0.94	0.93	0.93	7500

(5) VGG16

• 총 필터 수: 4,320개

• 이미지 1장 당 FLOPs : 30,713,485,342 (약 30.71 GFLOPs)
  이미지 7,500장 : 약 226.30 TFLOPs

• Test Accuracy : 0.9649

• Confusion Matrix
  
  

  Class	Precision	Recall	F1-Score	Support
  Arborio	1.00	0.97	0.98	1500
  Basmati	0.88	1.00	0.94	1500
  Ipsala	0.97	1.00	0.99	1500
  Jasmine	0.99	0.86	0.92	1500
  Karacadag	0.99	1.00	1.00	1500
  Accuracy			0.96	7500
  Macro Avg	0.97	0.96	0.96	7500
  Weighted Avg	0.97	0.96	0.96	7500

(6) VGG 경량화

• 총 필터 수: 2,688개

• 이미지 1장 당 FLOPs : 27,938,627,102 (약 27.94 GFLOPs)
  이미지 7,500장 : 약 290.54 TFLOPs

• Test Accuracy : 0.9227

• Confusion Matrix
  
  

  Class	Precision	Recall	F1-Score	Support
  Arborio	1.00	0.89	0.94	1500
  Basmati	0.78	1.00	0.88	1500
  Ipsala	0.99	1.00	0.99	1500
  Jasmine	0.99	0.72	0.83	1500
  Karacadag	0.93	1.00	0.96	1500
  Accuracy			0.92	7500
  Macro Avg	0.94	0.92	0.92	7500
  Weighted Avg	0.94	0.92	0.92	7500

(7) VGG Custom

• 총 필터 수: 288개

• 이미지 1장 당 FLOPs : 1,203,943,966 (약 1.20 GFLOPs)
  이미지 7,500장 : 약 9.02 TFLOPs

• Test Accuracy : 0.9909

• Confusion Matrix
  
  

  Class	Precision	Recall	F1-Score	Support
  Arborio	0.97	0.99	0.98	1500
  Basmati	1.00	1.00	1.00	1500
  Ipsala	1.00	1.00	1.00	1500
  Jasmine	1.00	0.97	0.98	1500
  Karacadag	0.99	1.00	0.99	1500
  Accuracy			0.99	7500
  Macro Avg	0.99	0.99	0.99	7500
  Weighted Avg	0.99	0.99	0.99	7500

(8) 성능비교

Filter의 개수를 줄이거나 Layer를 제거한 모델들의 일반화 성능이 더욱 높게 나왔다.

  위 그림은 FLOPs vs Test Accuracy 그래프이다. 해당 그래프는 왼쪽 아래로 갈수록 성능은 낮고 계산량은 많으며 오른쪽 위로 갈수록 성능은 높고 계산량은 적은 모델임을 의미한다.
  ‘Rice Image Dataset’을 기준으로 평가했을 때, VGG Custom 모델이 가장 높은 정확도와 비교적 낮은 FLOPs를 동시에 달성하며 최고의 효율을 보이는 모델로 판단된다. GoogLeNet Light 역시 높은 정확도와 상대적으로 낮은 연산량으로 효율적인 구조임을 확인할 수 있다.   반면 CNN Light는 FLOPs가 약 0.056TFLOPs 수준으로 가장 낮은 연산량을 보였지만 Test Accuracy가 0.9 미만으로 일반화 성능이 부족하다고 판단되어 실사용에는 적합하지 않은 모델로 분류하였다.

  위 그림은 각 모델의 Accuracy / TFLOPs를 시각화한 그래프이다. 이를 통해 CNN Light의 계산 효율이 매우 높음을 확인할 수 있지만 정확도의 뒷받침이 없을 경우 효율성만으로는 모델 선택이 어렵다는 점을 보여준다.
  하지만 CNN Light는 Validation Accuracy 0.9970, Validation Loss 0.0108로 학습 성능은 매우 우수하게 나타났다. 따라서 ‘Rice Image Dataset’과 같이 이미지 전처리가 잘 되어 있고 과적합에 대한 제약이 비교적 적은 환경에서는 극단적으로 연산량을 줄인 모델도 시도해볼 수 있다고 판단된다.

  위 그림은 Filter 수와 정확도의 관계를 분석한 Filter vs Test Accuracy 그래프이다. 해당 그래프에서는 Filter 수가 많다고 해서 반드시 성능이 좋은 것은 아님을 알 수 있다.
  실제로 VGG Custom, GoogLeNet Light 등은 비교적 적은 수의 필터로도 높은 정확도를 달성하였으며 오히려 필터 수가 적은 모델들이 더 뛰어난 일반화 성능을 보이기도 했다.
  서론에서 언급한 바와 같이 GoogLeNet처럼 Filter 개수가 지나치게 많은 구조는 학습이 불안정해지거나 정보가 소실되어 학습되지 않는 형상이 발생할 수 있다. 특히 ‘Rice Image Dataset’처럼 비교적 단순한 이미지의 경우 이러한 문제는 더욱 뚜렷하게 나타날 수 있으므로 주의가 필요하다.

5. 결론

  본 프로젝트에서는 모델 구조를 단순히 깊게 설계하거나 필터 수를 늘리는 방식보다는 학습에 실질적으로 기여하지 않는 구조를 제거하는 경량화 전략이 오히려 더 나은 성능을 낼 수 있음을 확인하였다.
  Feature Map을 시각적으로 확인한 결과, 일부 모델에서는 이미지가 비교적 단순하고 전처리가 잘 되어 있음에도 불구하고 의미 있는 특성 추출에 기여하지 않는 필터들이 다수 존재하였다. 따라서 필터 수를 줄이거나 레이어를 삭제하는 방식으로 모델을 경량화한 결과, 실제 테스트 성능에서 오히려 일반화가 더 잘 되는 현상을 확인할 수 있었다.
  실제로 ‘4. 모델별 일반화 성능 비교‘에서 확인할 수 있듯이 경량화된 모델들이 오히려 더 우수한 성능을 보이는 경우가 많았으며 이는 필터 수가 많다고 반드시 좋은 모델이 되는 것은 아님을 보여주는 결과였다.   이를 바탕으로 CNN Light의 압도적으로 낮은 계산량과 VGG Custom의 뛰어난 일반화 성능이라는 각 모델의 장점을 결합한 최종 개선 모델을 설계하였다. 이 모델은 CNN Light처럼 8 → 16 필터 구조를 유지하면서 VGG Custom과 같이 두 번째 풀링 이전에 Convolution 층을 추가하여 표현력을 강화하였고 Global Average Pooling과 Dropout을 적용하여 경량화와 성능 모두를 고려하였다.

(1) 최종 모델

• CNN Light와 같이 필터의 개수를 8 → 16으로 제한하여 CNN Light의 극단적으로 적은 계산량을 가져가고 VGG Custom과 같이 두 번째 풀링 이전에 Convolution 층을 추가하여 표현력을 확보하였다. 또한 Global Average Pooling과 Dropout을 적용하여 경량화와 성능 모두를 고려한 모델이다.

  def final_model(input_shape, num_classes):
      inputs = tf.keras.Input(shape=input_shape)
      x = tf.keras.layers.Conv2D(8, (3,3), activation='relu', padding='same')(inputs)
      x = tf.keras.layers.MaxPooling2D((2,2), strides = (2,2))(x)
      x = tf.keras.layers.Conv2D(16, (3,3), activation='relu', padding='same')(x)
      x = tf.keras.layers.Conv2D(16, (3,3), activation='relu', padding='same')(x)
      x = tf.keras.layers.Conv2D(16, (3,3), activation='relu', padding='same')(x)
      x = tf.keras.layers.MaxPooling2D((2,2), strides = (2,2))(x)
      x = layers.GlobalAveragePooling2D()(x)
      x = tf.keras.layers.Flatten()(x)
      x = tf.keras.layers.Dense(512, activation='relu')(x)
      x = layers.Dropout(0.3)(x)
      outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)
      model = tf.keras.Model(inputs, outputs)
      return model
  
  final_model = final_model(input_shape=img_size + (3,), num_classes=5)
  final_model.compile(optimizer='adam',
                    loss='categorical_crossentropy',
                    metrics=['accuracy'])
  final_model.summary()
  

Final Model Summary

Total params: 17,301 (67.58 KB)
Trainable params: 17,301 (67.58 KB)
Non-trainable params: 0 (0.00 B)

Model Evaluation

  Restoring model weights from the end of the best epoch: 34.

Best score인 34번 째 epoch의 evaluation은 아래와 같다.
Train Accuracy: 0.9899
Train Loss: 0.0310
Validation Accuracy: 0.9897
Validation Loss: 0.0305

Feature Map 시각화

Final Model 일반화 성능

• 총 필터 수: 56개

• 이미지 1장 당 FLOPs : 167,860,766 (약 0.17 GFLOPs)
  이미지 7,500장 : 약 1.26 TFLOPs

• Test Accuracy : 0.9533

• Confusion Matrix
  
  

  Class	Precision	Recall	F1-Score	Support
  Arborio	0.91	0.97	0.94	1500
  Basmati	0.98	0.93	0.96	1500
  Ipsala	0.99	1.00	0.99	1500
  Jasmine	0.93	0.92	0.92	1500
  Karacadag	0.96	0.95	0.95	1500
  Accuracy			0.95	7500
  Macro Avg	0.95	0.95	0.95	7500
  Weighted Avg	0.95	0.95	0.95	7500

• Final Model은 Test Accuracy 0.9533, 필터 수 56개, 최종 연산량 1.26 TFLOPs로 GoogLeNet Light보다 더 높은 정확도를 유지하면서도 계산량은 더욱 낮은 수준을 달성하였다.

(2) 최종 성능 비교표

  위의 시각화된 성능 비교 그래프에서 확인할 수 있듯이 Final Model은 정확도와 효율성 측명 모두에서 우상단에 위치한다. 이는 단순히 계산량만 줄인 것이 아닌 효과적인 구조 설계를 통해 실질적인 성능 개선까지 달성한 사례라 할 수 있다.
  CNN Light와 같이 극단적으로 연산량을 줄인 모델과 비교해보면 Final Model은 약간의 계산량을 추가함으로써 현실적인 성능 수준을 확보한 균형 잡힌 모델로 평가된다. 이는 경량화 모델 설계시 성능-연산량의 균형이 중요하다는 점을 잘 보여준다.

(3) 연구 의의와 활용 가능성

  본 프로젝트는 Feature Map을 기반으로 시각적으로 분석하여 의미없는 필터를 제거하는 방식으로 모델 경량화를 시도하였다. 이는 기존 연구에서 다뤄지지 않았던 접근 방법으로 다양한 CNN 구조를 실험적으로 비교하고 FLOPs 계산량 및 필터 수와의 관계를 장량적으로 분석하였다. 이로써 단순한 구조 최적화만으로도 높은 성능을 유지하면서 연산 효율성을 극대화할 수 있음을 입증하였다.
  최종적으로 제안된 Final Model은 낮은 연산량에도 불구하고 95% 이상의 정확도를 유지하며 성능과 효율의 균형을 모두 고려한 모델 설계가 가능함을 실증적으로 확인하였다. 이는 향후 모바일 디바이스나 엣지 컴퓨팅 환경처럼 제한된 연산 자원 내에서도 실용적인 딥러닝 모델을 구현한느 데에 참고할 수 있는 유의미한 사례가 될 수 있다.

6. Reference

1. Koklu, Murat. “Rice Image Dataset.” Kaggle. Accessed March 26, 2025. https://www.kaggle.com/datasets/muratkokludataset/rice-image-dataset/data.

2. Joshi, Shardul. “Rice Classification Using VGG16 - 99% Accuracy.” Kaggle, September 8, 2022. https://www.kaggle.com/code/sharduljoshi29/rice-classification-using-vgg16-99-accuracy.

3. 최진영. “산업인공지능 수업자료”. 아주대학교 산업공학과. 2024.

Text CNN

• Text CNN은 text 데이터를 처리하고 분류하기 위해 CNN을 사용하는 모델을 말한다. CNN은 주로 이미지 데이터를 처리하는데 사용되지만 텍스트 데이터 처리에도 성능이 좋다는 것이 Yoon Kim 박사의 논문을 통해 공개 되었다.

• 일반적으로 문장을 Word Embedding 벡터로 변환한 후 CNN 입력으로 사용하게 된다.

• 텍스트 데이터를 임베딩한 후 CNN을 사용해 분류작업을 수행하는 것이 일반적인 진행 순서이다.
  

  

Word Embedding

• Word Embedding은 단어를 벡터로 표현하는 방법으로 단어를 밀집 표현으로 변환하는 것으로 비슷한 의미의 단어들은 벡터 공간에서 가깝게 위치한다.

One-Hot Encoding의 문제점

• One-Hot Encoding의 경우 Index 값만 1이고 나머지는 0으로 표현된다. 이런 벡터 혹은 행렬의 값 대부분이 0으로 표현되는 방법을 희소 표현(Sparse Representation)이라고 한다.

• 이러한 희소 벡터의 문제점은 단어의 개수가 늘어나면 벡터의 차원이 한 없이 커진다. 예를 들어 10,000개의 단어가 있다면 벡터의 차원이 10,000개여야 한다. 인덱스에 해당되는 부분은 1이고 나머지는 0의 값을 가지는데, 이러한 벡터 표현은 공간적 낭비를 불러 일으킨다.

Dense Representation(밀집 표현)

• 희소 표현과 반대되는 표현으로 밀집 표현이 있다. 밀집 표현은 벡터의 차원을 단어 집합의 크기로 상정하지 않고 사용자가 설정한 값으로 모든 단어의 벡터 표현의 차원을 맞춘다. 또한 이 과정에서 더 이상 0과 1만 가진 값이 아니라 실수 값을 가지게 된다.

• 단어의 의미를 내포한 정보를 압축된 형태로 제공하여 다양한 자연어 처리 작업에서 더 효과적으로 사용된다.

  	희소 표현	밀집 표현
  벡터 차원	어휘 전체 크기와 동일한 고차원 벡터	일반적으로 낮은 차원으로 구성
  값의 분포	해당 단어에 해당하는 한 위치만 1, 나머지는 0	모든 차원이 의미 있는 값을 가지며 연속적인 실수 값으로 표현
  의미 반영	단어 간의 유사성을 반영하지 못한 서로 다른 단어들은 서로 완전히 독립적인 벡터	단어 간의 의미적, 문법적 유사성을 벡터 공간 내의 거리나 방향으로 반영할 수 있음
  효율성	대부분의 값이 0이기 때문에 메모리 비효율적일 수 있음	저차원 벡터 사용으로 메모리와 계산 효율성이 높음

  
  

Generative Adversarial Nets(GANs)

• 두 신경망이 경쟁적으로 학습하여 하나는 데이터를 생성하고 다른 하나는 이를 판별하며 서로의 성능을 개선하는 딥러닝 모델

• 2014년 Ian J. Goodfellow 등이 발표한 논문 ‘Generative Adversarial Nets’에서 제안되어 해당 논문에서는 지폐 위조범(Generator)과 경찰(Discriminator)에 비유하였다.

• 사람이 인공지능을 지도학습할 필요가 없이 기계 스스로 학습할 수 있는 길을 열었다는 점에서 뜨거운 반응을 얻었으며 이미지, 음성 신호 및 자연어 등의 다양한 분야에서 데이터를 새로 생성하거나 재구성할 수 있다.

  

• Generator는 임의의 벡터를 입력 받아 가짜 데이터를 만들어 반별자 네트워크를 속이도록 훈련

• Discriminator는 실제 학습 데이터와 Generator가 만든 가짜 데이터를 입력으로 받아 훈련 세트에서 온 데이터인지 생성자 네트워크가 만든 데이터인지 판별하는 기준을 설정하면서 생성자의 능력 향상에 적응해간다.

GANs 작동원리

• Discriminator 네트워크는 전달된 이미지가 실제 이미지인지 가짜 이미지인지를 판별할 수 있는 일반적인 Convolution Network이다.

• 일반 Convolution 분류기는 이미지를 입력 받아 확률을 예측하기 위해 Maxpooling과 같은 기술을 사용하여 다운 샘플링하는 반면, Generator는 랜덤 노이즈 벡터를 입력 받아 이미지를 만드는 업샘플링을 한다.

• 수학적 표현
  $min_G max_D V(D,G) = \mathbb{E_{x\sim p_{data}(x)}}[logD(x)] + \mathbb{E_{z\sim p _ {z}(z)}}[log(1-D(G(z)))]$
  

  1. D가 아주 뛰어날 때, $x$가 실제로 원본에서 온 것이라면 $D(x) = 1$이 될 것이고 $G(z)$에서 온 것이라면 $D(G(z)) = 0$이 될 것이다.

  2. 만약 $G(z)$가 완벽하게 위조한다면 $D(x) = \frac{1}{2}$이 될 것이다.

  3. D의 입장에서 V의 최대값은 0이 되며 G의 입장에서 최소값은 $-\infty$이다.
     \(Max \Rightarrow log(1) + log(1) = 0\) \(Min \Rightarrow \lim _{x \rightarrow \infty} log(x) = -\infty\)

GANs 활용

• 실제 이미지를 학습해 가짜 이미지를 만드는데 활용되며 nvidia는 2017년 유명인 20만 명의 사진을 학습시켜 실존하지 않는 사람들의 사진을 무한대로 만들어낼 수 있는 기술을 선보이기도 하였다.

• 영상 합성에도 사용되며 2017년 8월 미국 워싱턴대학교 연구진은 버락 오바마 전 미국 대통령의 가짜 영상을 만들어 화제가 되기도 하였다.

• MIT의 한 연구진은 수천 개의 이미지와 시를 쌍으로 학습시켜 AI가 이미지를 보고 시를 만들어내도록 하는 연구를 진행하기도 하였으며 30명의 영문학 전문가를 포함한 500명에게 AI가 만든 시와 인간이 쓴 시를 구별하도록 했는데, 이중 60%만 AI가 쓴 시를 선별해 냈다.

• 위와 같은 예시로 불균형 데이터를 갖는 분류 문제에서 GANs를 이용하여 적은 수의 불균형 데이터를 학습하여 비슷한 유형의 불균형 데이터를 생성한다.

GANs의 단점

• Model Collapsing : 이 현상은 학습 모델이 실제 데이터의 분포를 정확히 따라가지 못하고 다양성을 잃어버리는 현상

• Oscillation : G와 D가 수렴하지 않고 진동하는 모양새를 보이는 경우

• G와 D 사이의 Imbalance : 학습을 진행할 때, 처음에 D가 성능이 너무 좋아져서 오히려 G가 학습이 잘 되지 않는 문제

Transformer Model

• Transformer는 병렬 처리와 Attention 메커니즘을 통해 빠르고 정확한 학습이 가능한 자연어 처리 모델 아키텍처이다.

• Transformer Model은 Self-attention 메커니즘을 사용해 시퀀스 데이터를 병렬로 처리하고 단어 간의 관계를 빠르고 정확하게 학습할 수 있는 딥러닝 모델이다.

• Transformer Model은 2017년 구글의 논문 ‘Attention is All You Need’에서 처음 제안되었으며 그 이후 많은 NLP 작업에서 중요한 역할을 하고 있다.

  

Self-Attention Mechanism

• Self-Attention은 시퀀스의 각 요소가 다른 모든 요소와의 관계를 고려하여 자신을 다시 계산하는 메커니즘이다.

• 각 단어가 문장 내 다른 모든 단어와의 관계(의존성)를 파악하여 중요도에 따라 가중치를 부여하여 문맥 정보와 긴 거리 의존성을 효과적으로 캡처할 수 있다.

• Self Attention에서는 Query, Key, Value라는 3가지 변수가 존재한다.
  
  

  Self Attention은 Query, Key, Value의 시작 값이 동일하여 ‘Self’가 앞에 붙었으며 중간 학습 weight에 의해 최종적인 Query, Key, Value가 달라지게 된다.

• Self Attention을 구하는 공식은 아래와 같다.
  \(Attention(Q, K, V) = Softmax \left( \frac{QK^T}{\sqrt{d_k}} V \right)\)

  

Transformer Model의 구조

• Transformer Model의 구조는 기본적으로 인코더-디코더 구조를 가지고 있다.

  

Encoder 구조

• 트랜스포머에서 인코더는 입력 문장의 정보를 추출해 내부 표현을 생성한다. 인코더는 여러 개의 인코더 레이어로 구성되며 각 레이어는 아래의 순서로 이루어져있다.
  

  Self-Attention → Add & Norm → Feed Forward → Add & Norm

Decoder 구조

• 트랜스포머에서 디코더는 인코딩 된 표현을 받아 출력 시퀀스를 생성하는 역할을 한다. 디코더 또한 여러 개의 디코더 레이어로 구성되며 각 레이어는 아래의 순서로 이루어져있다.
  

  Masked Self-Attention → Add & Norm → Encoder-Decoder Attention → Add & Norm → Feed Forward → Add & Norm

오늘의 회고

• 여태 학습하였던 것과 달리 여러 응용 모델을 학습하였다. 응용 모델의 가장 큰 주안점은 Transformer계열 모델이다. nvidia 블로그에 따르면 AI의 발전은 Transformer 이전과 이후로 또 한 번 나뉜다고 한다. Transformer 계열의 BERT계열 모델을 사용해 본 적이 있는데, Transformer의 기본적인 구조를 곱씹어보며 복습해야겠다.

Natural Language Processing

• NLP는 인간의 언어 현상을 컴퓨터와 같은 기계를 이용해서 묘사할 수 있도록 연구하고 이를 구현하는 인공지능 분야 중 하나이다. NLP는 언어의 문법적 구조를 분석하고 문장의 의미를 파악하며 맥락을 이해하는 등 다양한 언어적 과제를 처리한다.

• NLP의 목표는 컴퓨터가 사람의 언어를 이해하고 자연스럽게 소통하여 유용한 정보를 제공하는 것이다.

NLP의 벡터화

BoW(Bag of Words)

• 문서 내 단어의 등장 빈도수를 벡터로 표현하는 방법이다.

• BoW 모델에서는 각 문서에 포함된 단어들의 순서나 문법은 무시하고 단어들이 얼마나 등장했는지만 고려한다.
  

• 해당 단어들의 빈도로 벡터를 구성하여 텍스트를 비교할 수 있다.

TF-IDF(Term Frequency-Inverse Document Frequency)

• 단어의 빈도(Term Frequency)와 해당 단어가 다른 문서에 등정하는 빈도(Inverse Document Frequency)를 결합해 단어의 중요도를 측정하는 방법이다.

Multinomial Naive Bayes(다항 나이브 베이즈)

• 다항 나이브 베이즈는 텍스트 분류와 같이 각 특징의 빈도에 기반해 카테고리를 예측하는 확률적 분류 알고리즘이다.

• Bayes’s Theorem(베이즈 정리) : 조건부 확률을 계산하는 공식으로 어떤 사건 A가 발생했을 때, 다른 사건 B가 발생할 확률은 아래와 같다.
  

• Bayes’s Theorem의 핵심은 서로 독립이라는 가정이며 한 특성의 값이 다른 특성의 값에 영향을 주지 않는다고 가정하고 확률을 계산한다

• Navie Bayes는 Bayes’s Theorem을 활용하여 특정 데이터가 특정 클래스에 속할 확률을 계산한다. 즉, 주어진 데이터에 특정 클래스가 나타날 확률을 계산하고 가장 높은 확률을 가진 클래스를 최종 분류 결과로 선택한다.

NLP의 사용

1. Library Import

import nltk  # 자연어 처리를 위한 NLTK 라이브러리 임포트
import os  # 운영체제 관련 기능을 사용하기 위한 os 모듈 임포트
import shutil  # 파일 및 디렉터리 관리를 위한 shutil 모듈 임포트
import numpy as np  # 수치 계산을 위한 NumPy 라이브러리 임포트
import torch  # PyTorch 딥러닝 프레임워크 임포트
import torch.nn as nn  # 신경망 모델을 위한 PyTorch의 nn 모듈 임포트
import torch.optim as optim  # 최적화 함수(Optimizer)를 위한 PyTorch의 optim 모듈 임포트
from torch.utils.data import TensorDataset, DataLoader  # 데이터 관리를 위한 PyTorch 모듈 임포트
from nltk.corpus import stopwords  # NLTK의 불용어(stopwords) 리스트 사용을 위한 임포트
from nltk.stem import WordNetLemmatizer  # 형태소 분석을 위한 WordNetLemmatizer 임포트
from sklearn.datasets import fetch_20newsgroups  # 뉴스 그룹 데이터셋 로드를 위한 임포트
from sklearn.model_selection import train_test_split  # 학습 및 테스트 데이터 분할을 위한 모듈 임포트

1. NLTK 데이터 다운로드 및 설정

# 기존 NLTK 데이터 삭제 (손상된 데이터 문제 해결)
shutil.rmtree('/root/nltk_data', ignore_errors=True)  # 손상된 NLTK 데이터를 제거하여 오류 방지

# NLTK 데이터 다운로드 및 경로 설정
nltk.data.path.append("/root/nltk_data")  # NLTK 데이터 저장 경로 설정
nltk.download('punkt')  # 단어 토큰화를 위한 Punkt 데이터 다운로드
nltk.download('punkt_tab')  # Punkt 관련 추가 리소스 다운로드
nltk.download('stopwords')  # 불용어(stopwords) 데이터 다운로드
nltk.download('wordnet')  # 형태소 분석을 위한 WordNet 데이터 다운로드
nltk.download('omw-1.4')  # WordNet 관련 추가 리소스 다운로드

1. 뉴스 그룹 데이터셋 로드 및 텍스트 전처리

# 뉴스 그룹 데이터셋 로드 (스포츠와 우주 관련 카테고리 선택)
categories = ['rec.sport.baseball', 'sci.space']  # 사용할 뉴스 그룹 카테고리 지정
newsgroups = fetch_20newsgroups(subset='train', categories=categories)  # 지정된 카테고리의 뉴스 데이터셋 로드
texts = newsgroups.data  # 뉴스 데이터의 본문 텍스트 가져오기
labels = newsgroups.target  # 뉴스 데이터의 레이블 (0: 야구, 1: 우주)

# 텍스트 전처리 함수 정의
def preprocess_text(text):
    text = text.lower()  # 모든 문자를 소문자로 변환
    tokens = nltk.word_tokenize(text)  # 문장을 단어 단위로 토큰화
    stop_words = set(stopwords.words('english'))  # 영어 불용어 로드
    tokens = [word for word in tokens if word.isalnum() and word not in stop_words]  # 특수문자 및 불용어 제거
    lemmatizer = WordNetLemmatizer()  # 형태소 분석을 위한 WordNetLemmatizer 객체 생성
    tokens = [lemmatizer.lemmatize(word) for word in tokens]  # 모든 단어에 대해 형태소 분석 수행
    return ' '.join(tokens)  # 형태소 분석된 단어를 공백으로 연결하여 반환

# 모든 뉴스 데이터에 대해 전처리 수행
preprocessed_texts = [preprocess_text(text) for text in texts]  # 리스트 컴프리헨션을 사용하여 모든 텍스트 전처리

1. 단어 사전 생성 및 시퀀스 변환

# 단어 사전 생성 (torchtext 없이 직접 생성)
vocab = {"<pad>": 0}  # "<pad>" 토큰을 인덱스 0으로 설정 (패딩 용도)
for text in preprocessed_texts:  # 모든 문서에 대해 반복
    for token in text.split():  # 각 문서를 단어 단위로 분리하여 반복
        if token not in vocab:  # 단어가 단어 사전에 없으면 추가
            vocab[token] = len(vocab)  # 현재 단어 개수를 인덱스로 할당하여 추가

# 단어를 정수 인덱스로 변환하여 시퀀스 데이터 생성
sequences = [[vocab.get(token, 0) for token in text.split()] for text in preprocessed_texts]  # 단어를 정수로 변환

1. 시퀀스 패딩 및 데이터셋 준비

# 시퀀스 패딩 (최대 길이에 맞춰 <pad> 인덱스(0) 추가)
max_length = max(len(seq) for seq in sequences)  # 가장 긴 시퀀스의 길이 계산
def pad_sequence(seq, max_len):
    if len(seq) < max_len:  # 시퀀스 길이가 최대 길이보다 짧을 경우
        seq = seq + [vocab["<pad>"]] * (max_len - len(seq))  # 패딩을 추가하여 길이를 맞춤
    else:
        seq = seq[:max_len]  # 시퀀스가 너무 길면 최대 길이까지만 유지
    return seq  # 패딩 완료된 시퀀스 반환

# 모든 데이터를 패딩 처리하여 동일한 길이로 변환
X = [pad_sequence(seq, max_length) for seq in sequences]  # 리스트 컴프리헨션을 사용하여 패딩 적용
X = np.array(X)  # NumPy 배열로 변환

# 레이블을 NumPy 배열로 변환 (정수 인코딩된 상태 유지)
y = np.array(labels)  # 레이블을 NumPy 배열로 변환

# 학습 및 평가 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  # 80% 학습, 20% 평가 데이터로 분리

1. PyTorch 데이터셋 및 데이터로더 생성

# NumPy 배열을 PyTorch 텐서로 변환
X_train_tensor = torch.tensor(X_train, dtype=torch.long)  # 정수 텐서 변환
y_train_tensor = torch.tensor(y_train, dtype=torch.long)  # 정수 레이블 변환
X_test_tensor = torch.tensor(X_test, dtype=torch.long)  # 정수 텐서 변환
y_test_tensor = torch.tensor(y_test, dtype=torch.long)  # 정수 레이블 변환

# TensorDataset과 DataLoader 생성
batch_size = 32  # 배치 크기 설정
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)  # 학습 데이터셋 생성
test_dataset = TensorDataset(X_test_tensor, y_test_tensor)  # 테스트 데이터셋 생성
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)  # 학습 데이터 로더 생성 (셔플 활성화)
test_loader = DataLoader(test_dataset, batch_size=batch_size)  # 테스트 데이터 로더 생성

1. 모델 정의 및 학습

# PyTorch 모델 정의 (Embedding -> Global Average Pooling -> Linear)
class TextClassificationModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, num_classes):
        super(TextClassificationModel, self).__init__()  # 부모 클래스 초기화
        self.embedding = nn.Embedding(vocab_size, embedding_dim)  # 임베딩 레이어 생성
        self.fc = nn.Linear(embedding_dim, num_classes)  # 선형 분류기 레이어 생성

    def forward(self, x):
        x = self.embedding(x)  # 단어 임베딩 적용
        x = torch.mean(x, dim=1)  # Global Average Pooling 수행
        x = self.fc(x)  # 선형 분류기 적용
        return x  # 출력 반환

1. 모델 학습 및 평가

# 디바이스 설정
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = TextClassificationModel(len(vocab), 128, 2).to(device)

# 손실 함수 및 옵티마이저 설정
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 모델 학습
for epoch in range(10):
    model.train()
    total_loss = 0
    for batch_x, batch_y in train_loader:
        batch_x, batch_y = batch_x.to(device), batch_y.to(device)
        optimizer.zero_grad()
        loss = criterion(model(batch_x), batch_y)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {total_loss:.4f}")

Recurrent Neural Network

• RNN은 순차적 데이터(텍스트, 시간 시계열 데이터 등)을 처리하기 위해 설계된 인공신경망이다.

• 텍스트는 문자의 Sequence로 되어 있다. RNN의 뉴런은 정보를 처리한 후 다시 자기 자신에게 되먹임할 수 있도록 Cycle을 가진다. 이러한 특징으로 데이터가 순환되기 때문에 과거의 정보를 기억하고 최신 데이터로 갱신될 수 있다.

• RNN architecture는 Input/Hidden/Output Layer로 구성되어 있으며 초기 weight 값들은 랜덤으로 생성된다.
  

  
  

  $x^{(t)}$는 Input Sequence의 $t$번째 값
  $h^{(t)}$는 Hidden Layer의 $t$번째 Neuron
  $o^{(t)}$는 Output Sequence의 $t$번째 값
  $U, V, W$는 각각의 Layer에서 사용되는 공유된 weight → RNN의 핵심개념
  

  $h_t$는 상태를 나타내며 $h_t = \tanh(h_{t-1}W_h + x_tW_x + b)$로 계산된다.

RNN 추론

• RNN의 추론은 보통의 신경망과 같이 오른쪽으로 진행하며 순전파를 수행한다.
  $h_{next} = \tanh(h_{prev}W_h + x_tW_x + b)$

• Hidden Layer의 뉴런은 $h^{(t)}=f(h^{(t-1)}, x^{(t)})$ 이며 activation function $f$는 hyperbolic tangent ($\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}$)를 사용한다.

• Hidden Neuron은 아래의 식으로 정의된다.
  

  \[h^{(t)} = \begin{cases} \tanh(W_{xh} \cdot x^{(1)}), t = 1\\ \tanh(W_{hh} \cdot h^{(h-1)} + W_{xh} \cdot x^{(t)}), t > 1 \end{cases}\]

• Output Layer는 $W_{hy}$를 이용해 Hidden Layer의 결과를 다시 한 번 연산하여 Output 산출 $o^{(t)} = W_{hy} \cdot h^{(t)}$

RNN 학습

• RNN의 학습은 일반적인 오차 역전파법을 적용하여 손실 함수에 대한 매개변수의 기울기를 계산한다.

• 시간 방향으로 펼친 신경망의 오차 역전파법이란 뜻으로 BPTT(Backpropagation Through Time)이라고 한다. RNN은 전후 관계를 갖는 Sequence를 다루기 때문에 기존의 역전파에 추가적인 시간의 개념이 도입된 BPTT를 이용한다.

• 일반적으로 RNN은 Softmax 함수를 사용한다.

  \[S(x_i) = \frac{e^{x_i}}{\sum _j e^{x_j}}\]

• Output Layer는 Softmax 함수를 이용해 $o^{(t)} = softmax(W_{hy} \cdot h^{(t)})$

• 시점 $k$ 에서 output neuron의 mini loss function을 $l^{(k)}$ 라고 하면 BPTT 수행 시 시점 $k$ 에서 단계적으로 고려되는 loss function $L^{(k)}$ 는 시점 $k$ 와 그 이후의 mini loss function들의 합으로 정의된다.

  \[L^{(k)} = \sum _{l = k} ^{\tau} l^{(l)}\]
• 이 이외의 다른 부분은 다른 역전파 방법들과 동일하다.
  1. Chain rule을 이용한 Gradient 계산
  2. Gradient를 이용한 Weight 계산
  3. Cross entropy loss function
• BPTT 문제점과 해결방안
  1. Gradient exploding
     • Gradient 크기를 제한하는 weight clipping을 통해 간단히 해결
     • $W_{hh}$를 normalization시켜 spectral radius가 1이 넘지 않게 하는 것으로도 해결 가능
  2. Gradient vanishing
     • Gradient vanishing은 해결하기가 쉽지 않다. 해당 문제를 해결하지 못하면 RNN은 sequence 전체가 아닌 짧은 범위의 몇 개 원소들만 기억하게 된다.
     • 긴 sequence를 올바로 학습하기 위해서 LSTM(Long Short Term Memory)를 사용한다.

RNN 구현

• RNN의 구조를 이용하여 NumPy를 사용해 간단한 RNN을 구현할 수 있다. RNN은 반복할 때, 이전에 계산한 정보를 재사용하는 for 루프를 이용하여 구현 가능하다.

    import numpy as np
  
    timesteps = 100
    input_features = 32
    output_features = 64
  
    inputs = np.random.random((timesteps, input_features))
  
    state_t = np.zeros((output_features, ))
  
    W = np.random.random((output_features, input_reatures))
    U = np.random.random((output_features, output_features))
    b = np.random.random((output_features, ))
  
    surccesive_outputs = []
  
    for input_t in inputs:
        output_t = np.tanh(np.dot(W, input_t) + np.dot(U, state_t) + b)
        surccesive_outputs.append(output_t)
        state_t = output_t
  
    final_output_sequence = np.stack(surccesive_outputs, axis = 0)
  

Long Short Term Memory

• LSTM은 기존의 RNN에서 출력과 멀리 있는 정보를 기억할 수 없다는 단점을 보완해 장/단기 기억을 가능하게 설계한 신경망 구조이다. 이는 RNN의 기울기 소실 문제 해결할 수 있다.

• LSTM은 RNN에 과거에서 현재까지 필요한 정보를 기억할 수 있는 기억 셀($c_t$)을 추가한다.
  LSTM 전용의 기억 메커니즘으로 3개의 입력($c_{t-1}, h_{t-1}, x_t$)으로부터 기억 셀($c_t$)을 구한다.
  출력인 은닉 상태는 $h_t = \tanh(c_t)$ 에 의해 계산한다.

• LSTM은 RNN에 출력 정보의 양을 조절하는 게이트를 추가한다. 학습 시 기울기를 원만하게 흘려 기울기 소실을 줄일 수 있다.

LSTM의 구조

• LSTM은 RNN의 Hidden State($h_t$)에 Cell State($C_t$)를 추가한 구조이다.
  

• 셀 스테이트(Cell state) $C_t$
  LSTM은 셀 스테이트에 정제된 구조를 가진 게이트(gate)라는 요소를 활용해서 정보를 더하거나 제거하는 기능을 수행한다.

• 시그모이드 레이어를 사용한 게이트 구현
  게이트는 각 구성요소가 영향을 주게 될지 결정하는 역할을 한다. 0이라는 값을 가지게 되면 해당 구성요소가 미래의 결과에 아무런 영향을 주지 않으며 1이라는 값을 가지게 되면 해당 구성요소가 확실히 미래의 예측 결과에 영향을 주도록 데이터가 흘러가게 한다.

• Forget 게이트
  셀 스테이트에서 어떤 정보를 버릴지 선택하는 게이트이다.
  $f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$ 로 표현되며 $h_{t-1}$과 $x_t$의 입력 값을 받아 0과 1 사이의 값을 출력한다.
  출력 값이 1인 경우 완전히 이 값을 유지하게 되고 출력 값이 0이 될 경우 완전히 이 값을 버린다.

• Input 게이트
  새로운 정보가 셀 스테이트에 저장될지를 결정하는 게이트이다.
  $$ i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) \

  \tilde{C_t} = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C) $$

• 오래된 셀 스테이트($C_{t-1}$)를 새로운 스테이트인 $C_t$로 업데이트
  $C_t = f_t * C_{t-1} + i_t * \tilde{C_t}$

• Output 게이트
  \(o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o) \\ h_t = o_t * \tanh(C_t)\)

  어떤 값을 출력할지 결정하는 시그모이드 레이어로 Cell State 값이 tanh함수를 거쳐서 -1과 1 사이의 값으로 출력한다. 시그모이드 레이어에서 얻은 값과 tanh 함수를 거쳐 얻은 값을 곱해서 출력

• LSTM의 단점

  1. 매개변수가 많아서 계산이 오래걸린다.
  2. LSTM을 대신할 게이트가 추가된 방법들이 많이 제안되었다. Gated Recurrent Unit(GRU) 등…

오늘의 회고

• NLP 중심으로 RNN과 LSTM을 학습하였다. 다른 모델도 마찬가지지만 해당 부분은 특히나 Architecture가 중요함을 깨달았으며 해당 Architecture을 수식으로 풀어보며 공부할 수 있었다.

• Early Stopping은 기계 학습에서 경사 하강법과 같은 반복 방법으로 학습자를 훈련할 때, 과적합을 방지하기 위해 사영되는 정규화의 한 형태이다. 학습 과정에서 모델의 성능이 더 이상 개선되지 않을 때, 학습을 조기에 멈추어 Overfitting을 방지할 수 있다.

• Early Stopping은 모델의 Overfitting을 방지하고 학습시간을 줄일 수 있다. 또한 최적의 성능을 보이는 지점을 찾아 학습을 조기에 멈추기 위해 사용된다. Validation Loss나 Validation Accuracy와 같은 지표를 모니터링하여 더 이상 성능이 햐상되지 않는 시점에서 훈련을 중지해야한다.

HyperParameter Tuning

• HyperParameter는 Learning Rate나 Optimizer 등과 같은 매개변수를 말하며 HyperParameter Tuning은 기계 학습 모델의 성능을 최적화하기 위해 모델의 Parameter값을 조정하는 과정을 뜻한다. 해당 과정은 모델의 성능을 향상시키고 주어진 데이터와 문제에 대해 최상의 예측 성능을 달하는 것을 목표로 한다.

• HyperParameter 목록

  이름	내용
  Learning Rate	가중치 업데이트의 크기를 결정하는 값
  Batch Size	한 번 학습할 데이터 샘플의 개수
  Epochs	전체 데이터셋을 몇 번 반복하여 학습할 지 결정
  Optimizer	모델 학습 과정을 최적화하는 알고리즘 선택
  Momentum	SGD와 같은 Optimizer에서 Gradient 업데이트에 관성을 추가하여 학습을 가속화하고 안정화
  DropOut Rate	학습 과정에서 무작위로 뉴런을 끄는 비율
  Regularization Parameter	과적합을 방지하기 위해 가중치에 패널티를 부여하는 값
  Learning Rate Decay	학습이 진행됨에 따라 학습률을 감소시키는 방법
  Activation Function	각 뉴런의 출력값을 결정하는 함수
  Initialization Method	가중치 초기화 방법

오늘의 회고

• 어제 학습하지 못한 Early Stopping과 HyperParameter Tuning에 대해 학습하였다.

please… MathJax…

Prompt test

[!NOTE] tip 테스트 입니다.

[!TIP] tip 테스트

[!INFO] info test

[!WARNING] warning test

[!danger] danger test

Tip

여기에 팁에 대한 내용을 작성하세요.

Info

여기에 정보를 안내하는 내용을 작성하세요.

Warning

여기에 주의해야 할 내용을 작성하세요.

Danger

여기에 심각한 위험 또는 경고 내용을 작성하세요.

Model Architecture(모델 구성)

• Model Architecture는 신경망에서 각 레이어의 구성, 연결 방식, 활성화 함수, 입력 및 출력 형태 등 전체 모델의 구조이다. 특히 딥러닝 모델에서 다양한 레이어가 어떻게 결합하여 데이터를 처리하고 결과를 도출하는지 정의하는 중요한 개념이다.

• 딥러닝 모델은 기본적으로 학습 과정을 통해 찾아낸 최적 weight들의 집합니다.

Epoch

• Training Data와 Validation Data로 나눈 데이터로 학습을 한다고 가정하면 아래와 같은 과정으로 Epoch이 수행된다.
  1. Training Data마다 각각 다른 비선형 그래프가 그려지고 Learning Rate를 조정하여 학습을 진행하면서 최적의 Loss값을 찾는다.
  2. 모든 Training Data에 대한 학습이 완료되면 모델이 학습한 내용을 바탕으로 Validation Data에 대한 예측을 수행한다.
  3. Validation Data의 Label과 모델의 예측 값을 비교하여 Loss값과 Accuracy를 계산하여 해당 Epoch에 대한 학습과 검증 결과로 Loss와 Accuracy 값이 출력된 후 학습된 모델이 저장된다.

Loss(손실)

• 실제 값과 예측 값의 차이 $|Y - \hat Y|$ 로 정의할 수 있다.
• Loss가 0에 가까울수록 좋다. 그러나 Loss가 낮다고 무조건 좋은 것은 아니며 Overfitting의 경우 Loss가 낮아도 테스트 데이터의 성능이 떨어질 수 있다.

Accuracy(정확도)

• 전체 $n$개의 샘플에 대해 각 샘플 $i$에 대해 모델의 예측과 실제 값이 일치하는 정도
  

• 전체 샘플

  \(\text{Accuracy} = \frac{1}{n}\sum_{i=1}^{n} \mathbf{1}\{y_i = \hat{y}_i\}\)
  

• 이진 분류

  \[\text{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN}\]

Pre-trained Model(사전 훈련 모델)

• 사전 훈련 모델은 이미 훈련이 끝난 모델 또는 모델 구성요소를 말하며 이 모델은 대규모 데이터셋에서 미리 학습되어 특정한 작업에 필요한 특성을 이미 학습한 상태이다.

• 사전 훈련 모델을 사용하는 이유는 인공지능 모델을 처음부터 구축하지 않아도 되어 시간과 자원을 절약하며 신속하게 활용할 수 있기 때문이다.

ResNet(Residual Network)

• ResNet은 Neural Network에서 발생하는 기울기 소실 문제를 해결하기 위해 Residual Connections을 도입한 사전 훈련 모델이다.
  Residual Connections(Skip connection)을 통해 깊은 네트워크에서도 Vanishing Gradient가 현저히 줄어든 상태로 학습을 진행할 수 있으며 ResNet은 50, 101, 152층 등 다양한 깊이의 모델로 구성된다.

• ResNet은 매우 깊은 신경망에서도 기울기 소실 문제를 효과적으로 해결하여 더 높은 정확도와 성능을 제공하는 딥러닝 모델을 구축할 수 있다.

VGG16

• Visual Geometry Group이라는 영국 옥스포드 대학교의 연구그룹이 제안한 CNN 구조로 13개 층의 Conv Layer와 3개의 Fully-Connected Layer를 합친 CNN 구조이다.

• VGG16은 깊고 구조화된 CNN 구조의 사전 학습 모델로 주로 이미지 인식과 분류 작업에 사용되는 사전 훈련 모델이다. VGG16은 심층 신경망의 설계를 단순화하면서도 강력한 성능을 유지하는데 초점을 맞춘 모델로 모든 합성곱 계층에서 3x3 크기의 필터를 사용하여 작은 수용영역으로도 복잡한 특징을 효과적으로 학습할 수 있도록 설계되었다.

• VGG16은 ImageNet 데이터셋으로 사전 훈련된 가중치를 제공하여 Transfer Learning에도 효과적으로 확용될 수 있다. 138M개의 파라미터를 가지는 대규모 모델이므로 연산량과 메모리 사용량이 크다는 단점이 있다.

Transfer Learning

• Transfer Learning은 사전 훈련된 모델을 그대로 사용하거나 추가 튜닝하여 새로운 문제에 적용함으로써 학습 시간을 단축하고 성능을 향상시키는 머신 러닝 기법이다. Transfer Learning 기법을 사용하면 대규모 데이터셋 또는 특정 과제에서 사전 훈련된 네트워크가 추출해 낸 구수준 특성(Feature)이나 모델 가중치(Weight)를 새로운 과제에 적용함으로써 학습시간을 단축하고 모델 성능을 개선할 수 있게 된다.

• 전이 학습에는 주로 3가지 기법 (Fine-Tuning, Feature Extraction, Zero-Shot Learning)이 있다.

Fine-tuning(미세 조정)

• 사전 훈련된 모델의 전체 혹은 일부 계층을 새로운 데이터셋에 맞게 재훈련하여 최적화하는 과정이다. 이미 학습된 가중치와 패턴을 활용하면서도 새로운 문제의 특성을 반영하기 위해 미세한 조정 과정을 거친다.

• 이미 학습된 가중치와 패턴을 활용하면서도 새로운 문제의 특성을 반영하기 위해 미세한 조정 과정을 거친다. 이 기법은 학습 자원이 많이 들 수 있지만 데이터셋 특유의 패턴을 보다 깊이 있게 반영하므로 더 높은 성능을 얻을 가능성이 크다.

1. Full Fine Tuning
   모델의 모든 파라미터를 새로운 데이터셋에 맞추어 학습화는 과정이다. 모델이 새로운 작업에 완전히 적응하도록 하기 때문에 가장 높은 성능을 기대할 수 있으나 많은 데이터와 계산 자원이 필요할 수 있으며 학습 시간이 오래 걸릴 수 있다.
   • 단계
     사전 학습된 모델 불러오기 $\rightarrow$ 모델의 구조 변경 (새로운 분류 레이어 추가) $\rightarrow$ 모든 레이어를 동결 해제 $\rightarrow$ 모델 컴파일 $\rightarrow$ 전체 모델 학습 $\rightarrow$ 모델 평가
2. Partial Fine Tuning
   모델의 일부 파라미터만 조정하는 방법이다. 모델의 상위 층(layer)만 미세 조정하고 하위 층은 그대로 두는 방식이다. 이렇게 하면 학습 시간이 단축되고 과적합(Overfitting) 문제를 줄일 수 있다.
   • 단계
     사전 학습된 모델 불러오기 $\rightarrow$ 모델의 구조 변경 (새로운 분류 레이어 추가) $\rightarrow$ 하위 레이어를 동결하고 상위 레이어만 동결 해제 $\rightarrow$ 모델 컴파일 $\rightarrow$ 일부 레이어 학습 $\rightarrow$ 모델 평가
3. 단계적 Fine Tuning
   먼저 모델의 상위 레이어만 재학습하고 그 다음 단계에서 하위 레이어까지 포함하여 재학습하는 접근법이다. 점진적으로 모델을 최적화하는데 사용된다.
   • 단계
     사전 학습된 모델 불러오기 $\rightarrow$ 모델의 구조 변경 (새로운 분류 레이어 추가) $\rightarrow$ 기본 레이어를 동결 $\rightarrow$ 모델 컴파일 $\rightarrow$ 상위 레이어 학습 $\rightarrow$ 하위 레이어 동결 해제 및 상위 레이어 일부 동결 유지 $\rightarrow$ 모델 재컴파일 및 전체 모델 학습 $\rightarrow$ 모델 평가
4. 하이브리드 방법
   여러 Fine Tuning 방법을 결합하여 사용하는 것으로 예를 들어 일부 레이어 Fine Tuning과 단계적 Fine Tuning을 결합하여 모델을 최적화한다.
   • 단계
     사전 학습된 모델 불러오기 $\rightarrow$ 모델의 구조 변경 (새로운 분류 레이어 추가) $\rightarrow$ 하위 레이어를 동결하고 상위 레이어만 동결 해제 $\rightarrow$ 모델 컴파일 $\rightarrow$ 상위 레이어 학습 $\rightarrow$ 일부 하위 레이어 동결 해제 $\rightarrow$ 모델 재컴파일 및 전체 모델 학습 $\rightarrow$ 모델 평가

Feature Extraction(특징 추출)

• 사전 훈련된 모델이 지닌 중간 계층의 가중치를 그대로 고정하여 특징 추출기(Feature Extractor)로 활용하는 방식이다. 그 후 마지막 분류 레이어만 새로 학습한다. 사전 훈련된 모델이 가진 광범위한 저수준 ~ 고수준 특징을 재활용하므로 데이터셋 규모가 크지 않아도 빠른 시간 내에 괜찮은 성능을 낼 수 있다.

• 새로운 문제와 사전 훈련 모델이 학습된 주제(도메인)가 유사할수록 특징 추출의 효율이 높다.

• Feature Extraction을 사용하는 이유는 적은 리소스로도 높은 성능을 끌어 올릴 수 있기 때문이다. Feature Extraction 방식은 사전 훈련된 모델의 중간 계층이 이미 학습한 범용적이고 고도화된 특징을 재활용한다는 점에서 매우 효과적인 전이 학습 접근법이다.

Zero-Shot Learning(제로샷 학습)

• 학습에 한 번도 등장하지 않은 클래스에 대해서도 모델이 예측을 수행할 수 있도록 하는 전이 학습 기법니다. 모델이 사전에 개념(Concept) 정보나 멀티모달(텍스트$\cdot$이미지) 표현을 학습해두고 이후 새로운 클래스가 등장했을 때, 유사도나 개념 연결로 그 클래스를 식별한다.

• 데이터가 없는 클래스에 대해서도 추론할 수 있어 확장성이 높고 희귀한 상황이나 긴급상황 분류 등에 활용될 수 있다.

• Zero-Shot Learning은 학습 데이터에 없는 새로운 클래스나 작업에도 추가학습 없이 즉시 대응하기 위해서 사용한다. 일반적인 머신 러닝이나 딥러닝 기법은 훈련 데이터에 등장한 클래스에 대해서만 예측 성능을 발휘한다는 한계를 가진다. 하지만 현실 세계에서는 학습 데이터로 준비되지 않은 수 많은 상황이나 새로운 분류 항목이 끊임없이 등장하기 때문에 추가적인 데이터 수집이나 재학습이 지속적으로 요구된다.

Model Comparison(모델 비교)

• 여러 기계학습 모델의 성능을 평가하고 비교해 특정 문제에 대해 가장 효과적인 모델을 선택하는 과정을 말한다.

• 다양한 모델 중에서 성능이 가장 우수한 모델을 선택하여 주어진 문제를 최적의 방식으로 해결하고 예측 정확도를 극대화하기 위해서 사용한다.

Overfitting(과적합)

• 학습 데이터를 과하게 학습해 실제 데이터에 대해서 오차가 증가하게 되는 것으로 모델이 학습 데이터의 노이즈나 특이한 패턴까지도 학습하여 일반적인 패턴을 제대로 학습하지 못하게 되기 때문에 발생한다.

• Overfitting의 발생 이유

  이유	설명
  모델 복잡성	너무 많은 파라미터나 복잡한 구조를 가진 모델은 학습 데이터에 과적합되기 쉽다.
  데이터 양의 부족	학습 데이터가 충분하지 않으면 모델이 데이터를 외우게 되어 과적합이 발생할 수 있다.
  노이즈 포함 학습	데이터에 노이즈가 많을 경우 모델이 노이즈까지 학습하여 새로운 데이터에 대한 성능이 떨어진다.

• Overfitting은 모델이 새로운 데이터에서도 좋은 성능을 발휘할 수 있도록 일반화 성능을 높이기 위해서 방지해야할 필요가 있다. 과적합된 모델은 학습 데이터에서는 높은 성능을 보일 수 있지만 실제로 사용될 새로운 데이터에 대해서는 성능이 크게 떨어질 수 있다.

• Overfitting 방지의 중요성

  항목	설명
  일반화 능력	모델이 새로운 데이터에 대해서도 좋은 성능을 유지하게 함
  신뢰성	다양한 데이터 상황에서도 일관된 성능을 보장
  적용 가능성	실제 환경에서의 예측 및 분석의 정확도 향상
  비용 절감	잘 일반화 된 모델은 데이터 수집 및 처리 비용을 줄일 수 있음

• Overfitting 방지 방법

  항목	설명
  드롭아웃(DropOut)	학습 과정에서 무작위로 뉴런을 끔으로써 과적합을 방지
  데이터 증강(Data Augmentation)	학습 데이터를 늘려서 다양한 상황에 대한 모델의 적응력을 높임
  정규화(Regularization)	L1, L2 정규화를 사용하여 큰 가중치 값을 가지지 않도록 함
  교차 검증(Cross-Validation)	데이터를 여러 번 나누어 검증하여 모델의 일반화 성능을 평가
  조기 종료(Early Stopping)	검증 데이터의 성능이 향상되지 않으면 학습을 조기 종료
  앙상블(Ensemble) 기법	여러 모델을 결합하여 예측 성능을 높임

Underfitting(과소적합)

• Underfitting은 모델이 데이터의 복잡성을 충분히 학습하지 못해 훈련 데이터와 새로운 데이터 모두에서 낮은 성능을 보이는 것으로 모델이 학습 과정에서 필요한 패턴이나 규칙을 제대로 파악하지 못한 채, 너무 단순화된 (혹은 충분히 훈련되지 않은) 형태로 머물러 있다는 뜻이다.

• 모델이 제대로 학습하지 못한다면 아무리 많은 데이터를 투입하거나 복잡한 아키텍처를 사용해도 원하는 성능을 얻기 어렵다. Underfitting에 대해 공부해야 모델이 학습 데이터의 본질적인 패턴을 충분히 학습하도록 설계$\cdot$최적화할 수 있다.

• Underfitting 방지 방법

  항목	방법
  모델 구조 개선	더 깊거나 복잡한 모델 사용, 비선형 활성화 함수 활용, 적절한 네트워크 아키텍처 선택
  데이터 활용 최적화	더 많은 데이터 확보, Data Augmentation(데이터 증강)기법 활용, 데이터 전처리 개선
  학습 설정 조정	적절한 학습률 설정, 충분한 학습 반복(Epoch 증가), 적절한 최적화 기법 선택

오늘의 회고

• Pre-Trained Model을 중심으로 모델을 사용하는 과정을 학습하였다. 현대 AI Engineer의 기본 소양은 잘 정제되어 있는 Model을 이용하는 것이다.

• 이번 해커톤 기간은 25.02.26(수) ~ 25.02.28(금) 3일간 진행된다.
  하지만 28일 10시에 예선발표가 있으므로 실제 개발할 수 있는 기간은 2일 남짓이다.

• 기본적으로 풀스택 2명, 클라우드 2명, AI 2명이 기본 팀 구성이지만 우리 팀은 풀스택 인원이 구성되지 않은채 클라우드 2명, AI 3명이서 팀이 구성되었다.

• 주제는 LLM을 이용한 서비스

• 어떤 서비스가 되었던 LLM에게 어떠한 정보를 주고 return을 받아 우리 서비스에 입력해야한다.

서비스 소개

• 우리는 알 수 없는 알고리즘에 파묻혀 살고 있다. 하루에도 알 수 없는 알고리즘이 우리를 이끈다. 우리는 이 영상을 왜 보는지, 이 노래를 왜 듣고 있는지 알 수 없는 일이 대부분이다. 이번 서비스는 알 수 있는 알고리즘 즉, 내가 이 노래를 왜 추천 받았는지 사용자가 알 수 있도록 하는 것이다.

  

• 사람들은 노래 추천을 받을 때, 장소, 기분, 날씨 등을 입력하기 마련이다. 예를 들어 ‘우울할 때 듣기 좋은 노래’, ‘비오는 날 듣기 좋은 노래’, 한강에서 듣기 좋은 노래’ 등으로 검색해보면 그에 맞게 노래 리스트를 만들어 놓았으며 수요 또한 많이 있는 걸 확인할 수 있다.

• 이뿐만 아니라 ‘마이너한 감성’을 꼭 선택하는 사람도 있다. 시간을 돌이켜 보면 ‘혁오 밴드’나 ‘잔나비’ 같은 가수들이 공중파 TV에 나왔을 때, 확인할 수 있던 반응을 생각해보면 ‘아… 나만 알고 있는 밴드였는데…’ 등이 많았다. 이러한 뜻은 메이저한 감성보다는 마이너한 감성을 찾는 수요도 많다는 뜻이다.

  

• 위와 같이 장소, 기분, 날씨, 감성의 모든 조화(Harmony)를 충족시키며 노래(Harmony)와 AI 추천 서비스를 합쳐 HarmonAI라는 이름이 탄생했다.

  

• HarmonAI가 원하는 User eXperience는 추천받은 노래로 ‘아… 이 기분, 장소, 날씨 그리고… 감성까지’라는 말이 나오는 것이다.

  

서비스 데모

FlowChart

• 우리 팀은 음악 추천 서비스를 하기로 하였다. 우리가 구상한 FlowChart는 아래와 같다.

  

• AI 팀의 주 목적은 프롬프트 엔지니어링과 FastAPI로 ChatGPT가 추천해준 가수와 노래 제목을 백엔드로 전달하는 역할이다.

• 하지만 우리는 백엔드 개발자가 없으므로 대부분의 API를 Python으로 구축하여 프롬프트 엔지니어링 후 백엔드로 전달하기로 하였다.

main.py (FastAPI 설계)

from location import GetLocation
from wheather import Wheather
from recommend_songs import Recommend_songs

app = FastAPI()

class RequestData(BaseModel):
    latitude: float
    longitude: float
    query: str
    pop: int

class ResponseData(BaseModel):
    title: str
    artist: str

class RecommendationResponse(BaseModel):
    recommendations: List[ResponseData]

@app.post("/api/music/recommend", response_model = RecommendationResponse)
async def response_process(data: RequestData):
    
    loca = GetLocation(data).convert_coordinates_to_address()
    now_whea = Wheather(f"{loca.split(sep = " ")[1]}", f"{loca.split(sep = " ")[2]}")

    playlist = Recommend_songs(data)
    my_musics = playlist.recommend(f"{loca}", f"{now_whea.get_sky()}", 5, 
    {"configurable": {"thread_id": "Censored"}}, "Korean")

    df = pd.DataFrame(my_musics.items(), columns=['artist', 'title'])
    df = df[['title', 'artist']]
    songs_list = df.to_dict(orient = 'records')

    return JSONResponse(content={"recommendations": songs_list})

• 백엔드와 Json형식으로 주고 받기로 하였다. 해당 규약으로 RequestData class를 짰다. 위도, 경도, 기분, temperature 순이다.

• 우리가 보낼 ResponseData는 제목, 가수 순이다. 하지만 백엔드와의 규약으로 recommendations 안에 Json형태로 보내야하기 때문에 List형식으로 다시 묶었다.

location.py (위도, 경도 → 지번 주소)

class GetLocation:
  def __init__(self, data):
    load_dotenv()
    self.data = data
    self.google_map_key = os.getenv("GOOLEMAPS_API")

  def convert_coordinates_to_address(self):
    """
    입력받은 위도, 경도를 도로명 주소 및 지번 주소로 변환하여 반환
    """
    data_dict = self.data.dict()  # Pydantic 모델을 dict로 변환
    lat = float(data_dict["latitude"])
    long = float(data_dict["longitude"])
    self.gmaps = googlemaps.Client(key=self.google_map_key)
    result = self.gmaps.reverse_geocode((lat, long), language="ko")  # language="ko" 추가!
    return result[0]['formatted_address']

• API 키는 기본적으로 .env로 숨겨서 처리하였다.

• 우리는 지오코딩의 기능을 이용할 것이므로 해당 링크를 참조하면 된다.

    results[]: {
    types[]: string,
    formatted_address: string,
    address_components[]: {
    short_name: string,
    long_name: string,
    postcode_localities[]: string,
    types[]: string
    },
    partial_match: boolean,
    place_id: string,
    postcode_localities[]: string,
    geometry: {
    location: LatLng,
    location_type: GeocoderLocationType
    viewport: LatLngBounds,
    bounds: LatLngBounds
    }
    }
  

• 우리가 필요한 건 formatted_address이고 나머지는 wheather에서 처리한다.

wheather.py (지번 주소 → 날씨)

class Wheather:
    def __init__(self, si, gu):
        data = pd.read_excel('./location_grids.xlsx')

        self.serviceKey = os.getenv("WEATHER_API")
        now = datetime.now()

        self.base_date = now.strftime("%Y%m%d")
        base_time = now.strftime("%H%M")
        self.si = si
        self.gu = gu
        grid = data[(data['1단계'] == self.si) & (data['2단계'] == self.gu)]
        if not grid.empty:
            self.nx = f"{grid.iloc[0]['격자 X']}"
            self.ny = f"{grid.iloc[0]['격자 Y']}"

        else:
            self.nx = '60'
            self.ny = '127'


        input_d = datetime.strptime(self.base_date + base_time, "%Y%m%d%H%M") - timedelta(hours = 1)
        input_datetime = input_d.strftime("%Y%m%d%H%M")

        input_date = input_datetime[:-4]
        input_time = input_datetime[-4:]

        self.url = f"http://apis.data.go.kr/1360000/VilageFcstInfoService_2.0/getUltraSrtFcst?serviceKey={self.serviceKey}&numOfRows=60&pageNo=1&dataType=json&base_date={self.base_date}&base_time={base_time}&nx={self.nx}&ny={self.ny}"

        self.deg_code = {0 : 'N', 360 : 'N', 180 : 'S', 270 : 'W', 90 : 'E', 22.5 :'NNE',
           45 : 'NE', 67.5 : 'ENE', 112.5 : 'ESE', 135 : 'SE', 157.5 : 'SSE',
           202.5 : 'SSW', 225 : 'SW', 247.5 : 'WSW', 292.5 : 'WNW', 315 : 'NW',
           337.5 : 'NNW'}

        self.pyt_code = {0 : '강수 없음', 1 : '비', 2 : '비/눈', 3 : '눈', 5 : '빗방울', 6 : '진눈깨비', 7 : '눈날림'}
        self.sky_code = {1 : '맑음', 3 : '구름많음', 4 : '흐림'}

    def get_info(self):
        response = requests.get(self.url, verify=False)
        res = json.loads(response.text)

        informations = dict()
        
        items = res.get('response', {}).get('body', {}).get('items', {}).get('item')
        if not items:
            # raise ValueError("예보 데이터를 가져오지 못했습니다. API 응답: " + json.dumps(res, ensure_ascii=False))
            return "오", "류"
        
        for item in items:
            cate = item['category']
            fcstTime = item['fcstTime']
            fcstValue = item['fcstValue']
            if fcstTime not in informations:
                informations[fcstTime] = dict()
            informations[fcstTime][cate] = fcstValue
            
        key = list(informations.keys())[-1]
        val = informations[key]

        return key, val

    def __call__(self):
        key, val = self.get_info()

        template = f"""{self.base_date[:4]}년 {self.base_date[4:6]}월 {self.base_date[-2:]}일 {key[:2]}시 {key[2:]}분 {(int(self.nx), int(self.ny))} 지역의 날씨는 """

        if val['SKY']:
            sky_temp = self.sky_code[int(val['SKY'])]
            template += sky_temp + " "

        if val['PTY'] :
            pty_temp = self.pyt_code[int(val['PTY'])]
            template += pty_temp
            if val['RN1'] != '강수없음' :
                rn1_temp = val['RN1']
                template += f"시간당 {rn1_temp}mm "

        if val['T1H'] :
            t1h_temp = float(val['T1H'])
            template += f" 기온 {t1h_temp}℃ "

        if val['REH'] :
            reh_temp = float(val['REH'])
            template += f"습도 {reh_temp}% "

        if val['VEC'] and val['WSD']:
            vec_temp = self.deg_to_dir(float(val['VEC']))
            wsd_temp = val['WSD']
            template += f"풍속 {vec_temp} 방향 {wsd_temp}m/s"

        return template

    def get_sky(self):
        key, val = self.get_info()
        if val == "류":
            return "맑음"
        
        template = ""

        if val['SKY']:
            sky_temp = self.sky_code[int(val['SKY'])]
            template += sky_temp

        return template



    def deg_to_dir(self, deg) :
        close_dir = ''
        min_abs = 360
        if deg not in self.deg_code.keys() :
            for key in self.deg_code.keys() :
                if abs(key - deg) < min_abs :
                    min_abs = abs(key - deg)
                    close_dir = self.deg_code[key]
        else :
            close_dir = self.deg_code[deg]
        return close_dir

• 기상청 단기 예보 서비스 API를 기본적으로 사용한다. 해당 링크를 참조하면 된다.

• 기상청에서 제공하는 location_grid는 3단계로 나누는데, 3단계까지 하면 search하는데 너무 오래 걸리고 날씨라는게 바로 옆동네라고 아주 달라지지 않으니 3단계는 제거하고 사용하였다.

• 1단계는 si로 받아오고 2단계는 gu로 받아와 사용하였다.

• 제대로된 주소를 불러오지 못한다면 60, 127 서울특별시 종로구로 설정하고 기상청API를 못 불러오는 경우가 있는데 이때 날씨는 맑음으로 return하기로 합의했다.

recommend_songs.py (주소, 날씨, query, pop → 추천 노래)

class Recommend_songs:
    def __init__(self, data):
        self.recommended_songs = {}
        self.data = data
        load_dotenv()
        
        client_id = os.getenv("SPOTIPY_CLIENT_ID")
        client_secret = os.getenv("SPOTIPY_CLIENT_SECRET")

        client_credentials_manager = SpotifyClientCredentials(client_id=client_id, client_secret=client_secret)
        self.sp = spotipy.Spotify(client_credentials_manager=client_credentials_manager)

        self.model = init_chat_model("gpt-4o-mini", model_provider="openai")

    def recommend(self, my_location, my_weather, target, config, language):
        data_dict = self.data.dict()  # Pydantic 모델을 dict로 변환
        pop = int(data_dict["pop"])
        query = data_dict["query"]
        self.prompt_template = ChatPromptTemplate.from_messages(
            [
                (
                    "system",
                    "사용자가 기분을 입력하면 감성을 분석해서 해당 감성에 맞는 장르의 노래를 추천해줘. "
                    f"현재 장소는 {my_location}이고 오늘의 날씨는 {my_weather}이야. "
                    f"오늘의 장소와 날씨, 그리고 사용자의 감성을 분석해서 어울리는 노래 {target * 2}개를 추천해줘. "
                    "사용자의 언어를 고려하여 해당 언어가 속한 국가의 노래 위주로 70%, "
                    "이외 글로벌한 국가에 대해 30% 비중으로 노래를 추천해줘. "
                    "출력 형식은 반드시 JSON이어야 하며, 자연어는 출력하지 마. "
                    "아티스트나 노래 제목에 쌍따옴표가 있는 경우 작은따옴표로 변환해서 출력해줘."
                    "출력 형식 예시는 다음과 같아: "
                    'iu. '
                    "반드시 Spotify에서 검색 가능한 공식 아티스트명과 곡 제목을 사용해줘."
                ),
                MessagesPlaceholder(variable_name="messages"),
            ]
            )
        class State(TypedDict):
            messages: Annotated[Sequence[BaseMessage], add_messages]
            language: str

        class CustomState(State):
            messages: list
            language: str

        while len(self.recommended_songs) < target:
            def call_model(state: CustomState):
                prompt = self.prompt_template.invoke(
                    {"messages": state["messages"], "language": state["language"]}
                )
                response = self.model.invoke(prompt)
                return {"messages": response}

            workflow = StateGraph(state_schema=CustomState)
            workflow.add_edge(START, "model")
            workflow.add_node("model", call_model)

            app = workflow.compile()

            input_messages = [HumanMessage(query)]
            output = app.invoke(
                {"messages": input_messages, "language": language}
            )

            music_dict = output["messages"].content
            music_dict = music_dict.replace("'", "")
            if not music_dict:
                continue
            try:
                music_dict = json.loads(music_dict)
            except:
                continue

            for key, value in music_dict.items():
                artist, track = key, value
                query = f"{artist} {track}"  # 아티스트 + 곡 제목 검색
                results = self.sp.search(q=query, type="track", limit=1)

                try:
                    track_popularity = results["tracks"]["items"][0]["popularity"]
                    if track_popularity <= pop:
                        self.recommended_songs[artist] = track

                    if len(self.recommended_songs) == target:
                        break
                except:
                    continue
        
        return self.recommended_songs